#
This Clause describes components that C++ programs may use to perform seminumerical operations.
2
#
The following subclauses describe components for complex number types, random number generation, numeric (n-at-a-time) arrays, generalized numeric algorithms, and mathematical constants and functions for floating-point types, as summarized in Table 125.
Table 125 — Numerics library summary [tab:numerics.summary]
🔗
Subclause
Header
🔗
Requirements
🔗
Floating-point environment
<cfenv>
🔗
Complex numbers
<complex>
🔗
Random number generation
<random>
🔗
Numeric arrays
<valarray>
🔗
Mathematical functions for floating-point types
<cmath>, <cstdlib>
🔗
Numbers
<numbers>
🔗
Linear algebra
<linalg>
🔗
Data-parallel types
<simd>

29.2 Numeric type requirements [numeric.requirements]

1
#
The complex and valarray components are parameterized by the type of information they contain and manipulate.
A C++ program shall instantiate these components only with a numeric type.
2
#
If any operation on T throws an exception the effects are undefined.
3
#
In addition, many member and related functions of valarray<T> can be successfully instantiated and will exhibit well-defined behavior if and only if T meets additional requirements specified for each such member or related function.
4
#
[Example 1: 
It is valid to instantiate valarray<complex>, but operator>() will not be successfully instantiated for valarray<complex> operands, since complex does not have any ordering operators.
— end example]
231)231)
In other words, value types.
These include arithmetic types, pointers, the library class complex, and instantiations of valarray for value types.

29.3 The floating-point environment [cfenv]

29.3.1 Header <cfenv> synopsis [cfenv.syn]

🔗
#define FE_ALL_EXCEPT see below #define FE_DIVBYZERO see below / optional #define FE_INEXACT see below / optional #define FE_INVALID see below / optional #define FE_OVERFLOW see below / optional #define FE_UNDERFLOW see below / optional #define FE_DOWNWARD see below / optional #define FE_TONEAREST see below / optional #define FE_TOWARDZERO see below / optional #define FE_UPWARD see below / optional #define FE_DFL_ENV see below namespace std { / types using fenv_t = object type; using fexcept_t = object type; / functions int feclearexcept(int except); int fegetexceptflag(fexcept_t* pflag, int except); int feraiseexcept(int except); int fesetexceptflag(const fexcept_t* pflag, int except); int fetestexcept(int except); int fegetround(); int fesetround(int mode); int fegetenv(fenv_t* penv); int feholdexcept(fenv_t* penv); int fesetenv(const fenv_t* penv); int feupdateenv(const fenv_t* penv); }
1
#
The contents and meaning of the header <cfenv> are a subset of the C standard library header <fenv.h> and only the declarations shown in the synopsis above are present.
[Note 1: 
This document does not require an implementation to support the FENV_ACCESS pragma; it is implementation-defined ([cpp.pragma]) whether the pragma is supported.
As a consequence, it is implementation-defined whether these functions can be used to test floating-point status flags, set floating-point control modes, or run under non-default mode settings.
If the pragma is used to enable control over the floating-point environment, this document does not specify the effect on floating-point evaluation in constant expressions.
— end note]
See also: ISO/IEC 9899:2024, 7.6
1
#
The floating-point environment has thread storage duration.
The initial state for a thread's floating-point environment is the state of the floating-point environment of the thread that constructs the corresponding thread object ([thread.thread.class]) or jthread object ([thread.jthread.class]) at the time it constructed the object.
[Note 1: 
That is, the child thread gets the floating-point state of the parent thread at the time of the child's creation.
— end note]
2
#
A separate floating-point environment is maintained for each thread.
Each function accesses the environment corresponding to its calling thread.

29.4 Complex numbers [complex.numbers]

1
#
The header <complex> defines a class template, and numerous functions for representing and manipulating complex numbers.
2
#
The effect of instantiating the primary template of complex for any type that is not a cv-unqualified floating-point type ([basic.fundamental]) is unspecified.
Specializations of complex for cv-unqualified floating-point types are trivially copyable literal types ([basic.types.general]).
3
#
If the result of a function is not mathematically defined or not in the range of representable values for its type, the behavior is undefined.
4
#
If z is an lvalue of type cv complex<T> then:
  • (4.1)
    the expression reinterpret_cast<cv T(&)[2]>(z) is well-formed,
  • (4.2)
    reinterpret_cast<cv T(&)[2]>(z)[0] designates the real part of z, and
  • (4.3)
    reinterpret_cast<cv T(&)[2]>(z)[1] designates the imaginary part of z.
Moreover, if a is an expression of type cv complex<T>* and the expression a[i] is well-defined for an integer expression i, then:
  • (4.4)
    reinterpret_cast<cv T*>(a)[2 * i] designates the real part of a[i], and
  • (4.5)
    reinterpret_cast<cv T*>(a)[2 * i + 1] designates the imaginary part of a[i].

29.4.2 Header <complex> synopsis [complex.syn]

🔗
namespace std { / [complex], class template complex template<class T> class complex; / [complex.ops], operators template<class T> constexpr complex<T> operator+(const complex<T>&, const complex<T>&); template<class T> constexpr complex<T> operator+(const complex<T>&, const T&); template<class T> constexpr complex<T> operator+(const T&, const complex<T>&); template<class T> constexpr complex<T> operator-(const complex<T>&, const complex<T>&); template<class T> constexpr complex<T> operator-(const complex<T>&, const T&); template<class T> constexpr complex<T> operator-(const T&, const complex<T>&); template<class T> constexpr complex<T> operator*(const complex<T>&, const complex<T>&); template<class T> constexpr complex<T> operator*(const complex<T>&, const T&); template<class T> constexpr complex<T> operator*(const T&, const complex<T>&); template<class T> constexpr complex<T> operator/(const complex<T>&, const complex<T>&); template<class T> constexpr complex<T> operator/(const complex<T>&, const T&); template<class T> constexpr complex<T> operator/(const T&, const complex<T>&); template<class T> constexpr complex<T> operator+(const complex<T>&); template<class T> constexpr complex<T> operator-(const complex<T>&); template<class T> constexpr bool operator=(const complex<T>&, const complex<T>&); template<class T> constexpr bool operator=(const complex<T>&, const T&); template<class T, class charT, class traits> basic_istream<charT, traits>& operator>(basic_istream<charT, traits>&, complex<T>&); template<class T, class charT, class traits> basic_ostream<charT, traits>& operator<(basic_ostream<charT, traits>&, const complex<T>&); / [complex.value.ops], values template<class T> constexpr T real(const complex<T>&); template<class T> constexpr T imag(const complex<T>&); template<class T> constexpr T abs(const complex<T>&); template<class T> constexpr T arg(const complex<T>&); template<class T> constexpr T norm(const complex<T>&); template<class T> constexpr complex<T> conj(const complex<T>&); template<class T> constexpr complex<T> proj(const complex<T>&); template<class T> constexpr complex<T> polar(const T&, const T& = T(); / [complex.transcendentals], transcendentals template<class T> constexpr complex<T> acos(const complex<T>&); template<class T> constexpr complex<T> asin(const complex<T>&); template<class T> constexpr complex<T> atan(const complex<T>&); template<class T> constexpr complex<T> acosh(const complex<T>&); template<class T> constexpr complex<T> asinh(const complex<T>&); template<class T> constexpr complex<T> atanh(const complex<T>&); template<class T> constexpr complex<T> cos (const complex<T>&); template<class T> constexpr complex<T> cosh (const complex<T>&); template<class T> constexpr complex<T> exp (const complex<T>&); template<class T> constexpr complex<T> log (const complex<T>&); template<class T> constexpr complex<T> log10(const complex<T>&); template<class T> constexpr complex<T> pow (const complex<T>&, const T&); template<class T> constexpr complex<T> pow (const complex<T>&, const complex<T>&); template<class T> constexpr complex<T> pow (const T&, const complex<T>&); template<class T> constexpr complex<T> sin (const complex<T>&); template<class T> constexpr complex<T> sinh (const complex<T>&); template<class T> constexpr complex<T> sqrt (const complex<T>&); template<class T> constexpr complex<T> tan (const complex<T>&); template<class T> constexpr complex<T> tanh (const complex<T>&); / [complex.tuple], tuple interface template<class T> struct tuple_size; template<size_t I, class T> struct tuple_element; template<class T> struct tuple_size<complex<T>>; template<size_t I, class T> struct tuple_element<I, complex<T>>; template<size_t I, class T> constexpr T& get(complex<T>&) noexcept; template<size_t I, class T> constexpr T&& get(complex<T>&) noexcept; template<size_t I, class T> constexpr const T& get(const complex<T>&) noexcept; template<size_t I, class T> constexpr const T&& get(const complex<T>&) noexcept; / [complex.literals], complex literals inline namespace literals { inline namespace complex_literals { constexpr complex<long double> operator""il(long double); constexpr complex<long double> operator""il(unsigned long); constexpr complex<double> operator""i(long double); constexpr complex<double> operator""i(unsigned long); constexpr complex<float> operator""if(long double); constexpr complex<float> operator""if(unsigned long); } } }

29.4.3 Class template complex [complex]

🔗
namespace std { template<class T> class complex { public: using value_type = T; constexpr complex(const T& re = T(), const T& im = T(); constexpr complex(const complex&) = default; template<class X> constexpr explicit(see below) complex(const complex<X>&); constexpr T real() const; constexpr void real(T); constexpr T imag() const; constexpr void imag(T); constexpr complex& operator= (const T&); constexpr complex& operator+=(const T&); constexpr complex& operator-=(const T&); constexpr complex& operator*=(const T&); constexpr complex& operator/=(const T&); constexpr complex& operator=(const complex&); template<class X> constexpr complex& operator= (const complex<X>&); template<class X> constexpr complex& operator+=(const complex<X>&); template<class X> constexpr complex& operator-=(const complex<X>&); template<class X> constexpr complex& operator*=(const complex<X>&); template<class X> constexpr complex& operator/=(const complex<X>&); }; }
1
#
The class complex describes an object that can store the Cartesian components, real() and imag(), of a complex number.

29.4.4 Member functions [complex.members]

🔗
constexpr complex(const T& re = T(), const T& im = T();
1
#
Postconditions: real() == re && imag() == im is true.
🔗
template<class X> constexpr explicit(see below) complex(const complex<X>& other);
2
#
Effects: Initializes the real part with other.real() and the imaginary part with other.imag().
3
#
Remarks: The expression inside explicit evaluates to false if and only if the floating-point conversion rank of T is greater than or equal to the floating-point conversion rank of X.
🔗
constexpr T real() const;
4
#
Returns: The value of the real component.
🔗
constexpr void real(T val);
5
#
Effects: Assigns val to the real component.
🔗
constexpr T imag() const;
6
#
Returns: The value of the imaginary component.
🔗
constexpr void imag(T val);
7
#
Effects: Assigns val to the imaginary component.

29.4.5 Member operators [complex.member.ops]

🔗
constexpr complex& operator+=(const T& rhs);
1
#
Effects: Adds the scalar value rhs to the real part of the complex value *this and stores the result in the real part of *this, leaving the imaginary part unchanged.
2
#
Returns: *this.
🔗
constexpr complex& operator-=(const T& rhs);
3
#
Effects: Subtracts the scalar value rhs from the real part of the complex value *this and stores the result in the real part of *this, leaving the imaginary part unchanged.
4
#
Returns: *this.
🔗
constexpr complex& operator*=(const T& rhs);
5
#
Effects: Multiplies the scalar value rhs by the complex value *this and stores the result in *this.
6
#
Returns: *this.
🔗
constexpr complex& operator/=(const T& rhs);
7
#
Effects: Divides the scalar value rhs into the complex value *this and stores the result in *this.
8
#
Returns: *this.
🔗
template<class X> constexpr complex& operator=(const complex<X>& rhs);
9
#
Effects: Assigns the value rhs.real() to the real part and the value rhs.imag() to the imaginary part of the complex value *this.
10
#
Returns: *this.
🔗
template<class X> constexpr complex& operator+=(const complex<X>& rhs);
11
#
Effects: Adds the complex value rhs to the complex value *this and stores the sum in *this.
12
#
Returns: *this.
🔗
template<class X> constexpr complex& operator-=(const complex<X>& rhs);
13
#
Effects: Subtracts the complex value rhs from the complex value *this and stores the difference in *this.
14
#
Returns: *this.
🔗
template<class X> constexpr complex& operator*=(const complex<X>& rhs);
15
#
Effects: Multiplies the complex value rhs by the complex value *this and stores the product in *this.
16
#
Returns: *this.
🔗
template<class X> constexpr complex& operator/=(const complex<X>& rhs);
17
#
Effects: Divides the complex value rhs into the complex value *this and stores the quotient in *this.
18
#
Returns: *this.

29.4.6 Non-member operations [complex.ops]

🔗
template<class T> constexpr complex<T> operator+(const complex<T>& lhs);
1
#
Returns: complex<T>(lhs).
🔗
template<class T> constexpr complex<T> operator+(const complex<T>& lhs, const complex<T>& rhs); template<class T> constexpr complex<T> operator+(const complex<T>& lhs, const T& rhs); template<class T> constexpr complex<T> operator+(const T& lhs, const complex<T>& rhs);
2
#
Returns: complex<T>(lhs) += rhs.
🔗
template<class T> constexpr complex<T> operator-(const complex<T>& lhs);
3
#
Returns: complex<T>(-lhs.real(),-lhs.imag().
🔗
template<class T> constexpr complex<T> operator-(const complex<T>& lhs, const complex<T>& rhs); template<class T> constexpr complex<T> operator-(const complex<T>& lhs, const T& rhs); template<class T> constexpr complex<T> operator-(const T& lhs, const complex<T>& rhs);
4
#
Returns: complex<T>(lhs) -= rhs.
🔗
template<class T> constexpr complex<T> operator*(const complex<T>& lhs, const complex<T>& rhs); template<class T> constexpr complex<T> operator*(const complex<T>& lhs, const T& rhs); template<class T> constexpr complex<T> operator*(const T& lhs, const complex<T>& rhs);
5
#
Returns: complex<T>(lhs) *= rhs.
🔗
template<class T> constexpr complex<T> operator/(const complex<T>& lhs, const complex<T>& rhs); template<class T> constexpr complex<T> operator/(const complex<T>& lhs, const T& rhs); template<class T> constexpr complex<T> operator/(const T& lhs, const complex<T>& rhs);
6
#
Returns: complex<T>(lhs) /= rhs.
🔗
template<class T> constexpr bool operator=(const complex<T>& lhs, const complex<T>& rhs); template<class T> constexpr bool operator=(const complex<T>& lhs, const T& rhs);
7
#
Remarks: The imaginary part is assumed to be T(), or 0.0, for the T arguments.
🔗
template<class T, class charT, class traits> basic_istream<charT, traits>& operator>(basic_istream<charT, traits>& is, complex<T>& x);
9
#
Preconditions: The input values are convertible to T.
10
#
Effects: Extracts a complex number x of the form: u, (u), or (u,v), where u is the real part and v is the imaginary part ([istream.formatted]).
11
#
If bad input is encountered, calls is.setstate(ios_base​::​failbit) (which may throw ios_base​::​​failure ([iostate.flags])).
12
#
Remarks: This extraction is performed as a series of simpler extractions.
Therefore, the skipping of whitespace is specified to be the same for each of the simpler extractions.
🔗
template<class T, class charT, class traits> basic_ostream<charT, traits>& operator<(basic_ostream<charT, traits>& o, const complex<T>& x);
14
#
Effects: Inserts the complex number x onto the stream o as if it were implemented as follows: basic_ostringstream<charT, traits> s; s.flags(o.flags(); s.imbue(o.getloc(); s.precision(o.precision(); s << '(' << x.real() << ',' << x.imag() << ')'; return o << s.str();
15
#
[Note 1: 
In a locale in which comma is used as a decimal point character, the use of comma as a field separator can be ambiguous.
Inserting showpoint into the output stream forces all outputs to show an explicit decimal point character; as a result, all inserted sequences of complex numbers can be extracted unambiguously.
— end note]

29.4.7 Value operations [complex.value.ops]

🔗
template<class T> constexpr T real(const complex<T>& x);
1
#
Returns: x.real().
🔗
template<class T> constexpr T imag(const complex<T>& x);
2
#
Returns: x.imag().
🔗
template<class T> constexpr T abs(const complex<T>& x);
3
#
Returns: The magnitude of x.
🔗
template<class T> constexpr T arg(const complex<T>& x);
4
#
Returns: The phase angle of x, or atan2(imag(x), real(x)).
🔗
template<class T> constexpr T norm(const complex<T>& x);
5
#
Returns: The squared magnitude of x.
🔗
template<class T> constexpr complex<T> conj(const complex<T>& x);
6
#
Returns: The complex conjugate of x.
🔗
template<class T> constexpr complex<T> proj(const complex<T>& x);
7
#
Remarks: Behaves the same as the C function cproj.
See also: ISO/IEC 9899:2024, 7.3.9.5
🔗
template<class T> constexpr complex<T> polar(const T& rho, const T& theta = T();
9
#
Returns: The complex value corresponding to a complex number whose magnitude is rho and whose phase angle is theta.
🔗
template<class T> constexpr complex<T> acos(const complex<T>& x);
1
#
Remarks: Behaves the same as the C function cacos.
See also: ISO/IEC 9899:2024, 7.3.5.1
🔗
template<class T> constexpr complex<T> asin(const complex<T>& x);
3
#
Remarks: Behaves the same as the C function casin.
See also: ISO/IEC 9899:2024, 7.3.5.2
🔗
template<class T> constexpr complex<T> atan(const complex<T>& x);
5
#
Remarks: Behaves the same as the C function catan.
See also: ISO/IEC 9899:2024, 7.3.5.3
🔗
template<class T> constexpr complex<T> acosh(const complex<T>& x);
7
#
Remarks: Behaves the same as the C function cacosh.
See also: ISO/IEC 9899:2024, 7.3.6.1
🔗
template<class T> constexpr complex<T> asinh(const complex<T>& x);
9
#
Remarks: Behaves the same as the C function casinh.
See also: ISO/IEC 9899:2024, 7.3.6.2
🔗
template<class T> constexpr complex<T> atanh(const complex<T>& x);
11
#
Remarks: Behaves the same as the C function catanh.
See also: ISO/IEC 9899:2024, 7.3.6.3
🔗
template<class T> constexpr complex<T> cos(const complex<T>& x);
13
#
Returns: The complex cosine of x.
🔗
template<class T> constexpr complex<T> cosh(const complex<T>& x);
14
#
Returns: The complex hyperbolic cosine of x.
🔗
template<class T> constexpr complex<T> exp(const complex<T>& x);
15
#
Returns: The complex base-e exponential of x.
🔗
template<class T> constexpr complex<T> log(const complex<T>& x);
16
#
Returns: The complex natural (base-e) logarithm of x.
For all x, imag(log(x)) lies in the interval [].
[Note 1: 
The semantics of this function are intended to be the same in C++ as they are for clog in C.
— end note]
17
#
Remarks: The branch cuts are along the negative real axis.
🔗
template<class T> constexpr complex<T> log10(const complex<T>& x);
18
#
Returns: The complex common (base-10) logarithm of x, defined as log(x) / log(10).
19
#
Remarks: The branch cuts are along the negative real axis.
🔗
template<class T> constexpr complex<T> pow(const complex<T>& x, const complex<T>& y); template<class T> constexpr complex<T> pow(const complex<T>& x, const T& y); template<class T> constexpr complex<T> pow(const T& x, const complex<T>& y);
20
#
Returns: The complex power of base x raised to the
The value returned for pow(0, 0) is implementation-defined.
21
#
Remarks: The branch cuts are along the negative real axis.
🔗
template<class T> constexpr complex<T> sin(const complex<T>& x);
22
#
Returns: The complex sine of x.
🔗
template<class T> constexpr complex<T> sinh(const complex<T>& x);
23
#
Returns: The complex hyperbolic sine of x.
🔗
template<class T> constexpr complex<T> sqrt(const complex<T>& x);
24
#
Returns: The complex square root of x, in the range of the right half-plane.
[Note 2: 
The semantics of this function are intended to be the same in C++ as they are for csqrt in C.
— end note]
25
#
Remarks: The branch cuts are along the negative real axis.
🔗
template<class T> constexpr complex<T> tan(const complex<T>& x);
26
#
Returns: The complex tangent of x.
🔗
template<class T> constexpr complex<T> tanh(const complex<T>& x);
27
#
Returns: The complex hyperbolic tangent of x.

29.4.9 Tuple interface [complex.tuple]

🔗
template<class T> struct tuple_size<complex<T>> : integral_constant<size_t, 2> {}; template<size_t I, class T> struct tuple_element<I, complex<T>> { using type = T; };
1
#
Mandates: I < 2 is true.
🔗
template<size_t I, class T> constexpr T& get(complex<T>& z) noexcept; template<size_t I, class T> constexpr T&& get(complex<T>& z) noexcept; template<size_t I, class T> constexpr const T& get(const complex<T>& z) noexcept; template<size_t I, class T> constexpr const T&& get(const complex<T>& z) noexcept;
2
#
Returns: A reference to the real part of z if I == 0 is true, otherwise a reference to the imaginary part of z.

29.4.10 Additional overloads [cmplx.over]

1
#
The following function templates have additional constexpr overloads: arg norm conj proj imag real
2
#
The additional constexpr overloads are sufficient to ensure:
  • (2.1)
    If the argument has a floating-point type T, then it is effectively cast to complex<T>.
  • (2.2)
    Otherwise, if the argument has integer type, then it is effectively cast to complex<double>.
3
#
Function template pow has additional constexpr overloads sufficient to ensure, for a call with one argument of type complex<T1> and the other argument of type T2 or complex<T2>, both arguments are effectively cast to complex<common_type_t<T1, T3>>, where T3 is double if T2 is an integer type and T2 otherwise.
If common_type_t<T1, T3> is not well-formed, then the program is ill-formed.

29.4.11 Suffixes for complex number literals [complex.literals]

1
#
This subclause describes literal suffixes for constructing complex number literals.
The suffixes i, il, and if create complex numbers of the types complex<double>, complex<long double>, and complex<float> respectively, with their imaginary part denoted by the given literal number and the real part being zero.
🔗
constexpr complex<long double> operator""il(long double d); constexpr complex<long double> operator""il(unsigned long d);
2
#
Returns: complex<long double>{0.0L, static_cast<long double>(d)}.
🔗
constexpr complex<double> operator""i(long double d); constexpr complex<double> operator""i(unsigned long d);
3
#
Returns: complex<double>{0.0, static_cast<double>(d)}.
🔗
constexpr complex<float> operator""if(long double d); constexpr complex<float> operator""if(unsigned long d);
4
#
Subclause [rand] defines a facility for generating (pseudo-)random numbers.
2
#
In addition to a few utilities, four categories of entities are described: uniform random bit generators, random number engines, random number engine adaptors, and random number distributions.
These categorizations are applicable to types that meet the corresponding requirements, to objects instantiated from such types, and to templates producing such types when instantiated.
[Note 1: 
These entities are specified in such a way as to permit the binding of any uniform random bit generator object e as the argument to any random number distribution object d, thus producing a zero-argument function object such as given by bind(d,e).
— end note]
3
#
Each of the entities specified in [rand] has an associated arithmetic type ([basic.fundamental]) identified as result_type.
With T as the result_type thus associated with such an entity, that entity is characterized:
If integer-valued, an entity may optionally be further characterized as signed or unsigned, according to numeric_limits<T>​::​is_signed.
4
#
Unless otherwise specified, all descriptions of calculations in [rand] use mathematical real numbers.
5
#
Throughout [rand], the operators bitand, bitor, and xor denote the respective conventional bitwise operations.
Further:
  • (5.1)
    the operator rshift denotes a bitwise right shift with zero-valued bits appearing in the high bits of the result, and
  • (5.2)
    the operator

29.5.2 Header <random> synopsis [rand.synopsis]

#include <initializer_list> / see [initializer.list.syn] namespace std { / [rand.req.urng], uniform random bit generator requirements template<class G> concept uniform_random_bit_generator = see below; / freestanding / [rand.eng.lcong], class template linear_congruential_engine template<class UIntType, UIntType a, UIntType c, UIntType m> class linear_congruential_engine; / partially freestanding / [rand.eng.mers], class template mersenne_twister_engine template<class UIntType, size_t w, size_t n, size_t m, size_t r, UIntType a, size_t u, UIntType d, size_t s, UIntType b, size_t t, UIntType c, size_t l, UIntType f> class mersenne_twister_engine; / [rand.eng.sub], class template subtract_with_carry_engine template<class UIntType, size_t w, size_t s, size_t r> class subtract_with_carry_engine; / partially freestanding / [rand.adapt.disc], class template discard_block_engine template<class Engine, size_t p, size_t r> class discard_block_engine; / partially freestanding / [rand.adapt.ibits], class template independent_bits_engine template<class Engine, size_t w, class UIntType> class independent_bits_engine; / partially freestanding / [rand.adapt.shuf], class template shuffle_order_engine template<class Engine, size_t k> class shuffle_order_engine; / [rand.eng.philox], class template philox_engine template<class UIntType, size_t w, size_t n, size_t r, UIntType.. consts> class philox_engine; / partially freestanding / [rand.predef], engines and engine adaptors with predefined parameters using minstd_rand0 = see below; / freestanding using minstd_rand = see below; / freestanding using mt19937 = see below; / freestanding using mt19937_64 = see below; / freestanding using ranlux24_base = see below; / freestanding using ranlux48_base = see below; / freestanding using ranlux24 = see below; / freestanding using ranlux48 = see below; / freestanding using knuth_b = see below; using philox4x32 = see below; / freestanding using philox4x64 = see below; / freestanding using default_random_engine = see below; / [rand.device], class random_device class random_device; / [rand.util.seedseq], class seed_seq class seed_seq; / [rand.util.canonical], function template generate_canonical template<class RealType, size_t digits, class URBG> RealType generate_canonical(URBG& g); namespace ranges { / [alg.rand.generate], generate_random template<class R, class G> requires output_range<R, invoke_result_t<G&> && uniform_random_bit_generator<remove_cvref_t<G>> constexpr borrowed_iterator_t<R> generate_random(R&& r, G&& g); template<class G, output_iterator<invoke_result_t<G&> O, sentinel_for<O> S> requires uniform_random_bit_generator<remove_cvref_t<G>> constexpr O generate_random(O first, S last, G&& g); template<class R, class G, class D> requires output_range<R, invoke_result_t<D&, G&> && invocable<D&, G&> && uniform_random_bit_generator<remove_cvref_t<G>> && is_arithmetic_v<invoke_result_t<D&, G&> constexpr borrowed_iterator_t<R> generate_random(R&& r, G&& g, D&& d); template<class G, class D, output_iterator<invoke_result_t<D&, G&> O, sentinel_for<O> S> requires invocable<D&, G&> && uniform_random_bit_generator<remove_cvref_t<G>> && is_arithmetic_v<invoke_result_t<D&, G&> constexpr O generate_random(O first, S last, G&& g, D&& d); } / [rand.dist.uni.int], class template uniform_int_distribution template<class IntType = int> class uniform_int_distribution; / partially freestanding / [rand.dist.uni.real], class template uniform_real_distribution template<class RealType = double> class uniform_real_distribution; / [rand.dist.bern.bernoulli], class bernoulli_distribution class bernoulli_distribution; / [rand.dist.bern.bin], class template binomial_distribution template<class IntType = int> class binomial_distribution; / [rand.dist.bern.geo], class template geometric_distribution template<class IntType = int> class geometric_distribution; / [rand.dist.bern.negbin], class template negative_binomial_distribution template<class IntType = int> class negative_binomial_distribution; / [rand.dist.pois.poisson], class template poisson_distribution template<class IntType = int> class poisson_distribution; / [rand.dist.pois.exp], class template exponential_distribution template<class RealType = double> class exponential_distribution; / [rand.dist.pois.gamma], class template gamma_distribution template<class RealType = double> class gamma_distribution; / [rand.dist.pois.weibull], class template weibull_distribution template<class RealType = double> class weibull_distribution; / [rand.dist.pois.extreme], class template extreme_value_distribution template<class RealType = double> class extreme_value_distribution; / [rand.dist.norm.normal], class template normal_distribution template<class RealType = double> class normal_distribution; / [rand.dist.norm.lognormal], class template lognormal_distribution template<class RealType = double> class lognormal_distribution; / [rand.dist.norm.chisq], class template chi_squared_distribution template<class RealType = double> class chi_squared_distribution; / [rand.dist.norm.cauchy], class template cauchy_distribution template<class RealType = double> class cauchy_distribution; / [rand.dist.norm.f], class template fisher_f_distribution template<class RealType = double> class fisher_f_distribution; / [rand.dist.norm.t], class template student_t_distribution template<class RealType = double> class student_t_distribution; / [rand.dist.samp.discrete], class template discrete_distribution template<class IntType = int> class discrete_distribution; / [rand.dist.samp.pconst], class template piecewise_constant_distribution template<class RealType = double> class piecewise_constant_distribution; / [rand.dist.samp.plinear], class template piecewise_linear_distribution template<class RealType = double> class piecewise_linear_distribution; }

29.5.3 Requirements [rand.req]

29.5.3.1 General requirements [rand.req.genl]

1
#
Throughout [rand], the effect of instantiating a template:
  • (1.1)
    that has a template type parameter named Sseq is undefined unless the corresponding template argument is cv-unqualified and meets the requirements of seed sequence.
  • (1.2)
    that has a template type parameter named URBG is undefined unless the corresponding template argument is cv-unqualified and meets the requirements of uniform random bit generator.
  • (1.3)
    that has a template type parameter named Engine is undefined unless the corresponding template argument is cv-unqualified and meets the requirements of random number engine.
  • (1.4)
    that has a template type parameter named RealType is undefined unless the corresponding template argument is cv-unqualified and is one of float, double, or long double.
  • (1.5)
    that has a template type parameter named IntType is undefined unless the corresponding template argument is cv-unqualified and is one of short, int, long, long long, unsigned short, unsigned int, unsigned long, or unsigned long.
  • (1.6)
    that has a template type parameter named UIntType is undefined unless the corresponding template argument is cv-unqualified and is one of unsigned short, unsigned int, unsigned long, or unsigned long.
2
#
Throughout [rand], phrases of the form “x is an iterator of a specific kind” shall be interpreted as equivalent to the more formal requirement that “x is a value of a type meeting the requirements of the specified iterator type”.
3
#
Throughout [rand], any constructor that can be called with a single argument and that meets a requirement specified in this subclause shall be declared explicit.

29.5.3.2 Seed sequence requirements [rand.req.seedseq]

1
#
A seed sequence is an object that consumes a sequence of integer-valued data and produces a requested number of unsigned integer values i,
[Note 1: 
Such an object provides a mechanism to avoid replication of streams of random variates.
This can be useful, for example, in applications requiring large numbers of random number engines.
— end note]
2
#
A class S meets the requirements of a seed sequence if the expressions shown in Table 126 are valid and have the indicated semantics, and if S also meets all other requirements of [rand.req.seedseq].
In Table 126 and throughout this subclause:
  • (2.1)
    T is the type named by S's associated result_type;
  • (2.2)
    q is a value of type S and r is a value of type S or const S;
  • (2.3)
    ib and ie are input iterators with an unsigned integer value_type of at least 32 bits;
  • (2.4)
    rb and re are mutable random access iterators with an unsigned integer value_type of at least 32 bits;
  • (2.5)
    ob is an output iterator; and
  • (2.6)
    il is a value of type initializer_list<T>.
Table 126 — Seed sequence requirements [tab:rand.req.seedseq]
🔗
Expression
Return type
Pre/post-condition
Complexity
🔗
S​::​result_type
T
T is an unsigned integer type of at least 32 bits.
🔗
S()
Creates a seed sequence with the same initial state as all other default-constructed seed sequences of type S.
constant
🔗
S(ib,ie)
Creates a seed sequence having internal state that depends on some or all of the bits of the supplied sequence [ib,ie).
🔗
S(il)
Same as S(il.begin(), il.end().
same as S(il.begin(), il.end()
🔗
q.generate(rb,re)
void
Does nothing if rb == re.
Otherwise, fills the supplied sequence [rb,re) with 32-bit quantities that depend on the sequence supplied to the constructor and possibly also depend on the history of generate's previous invocations.
🔗
r.size()
size_t
The number of 32-bit units that would be copied by a call to r.param.
constant
🔗
r.param(ob)
void
Copies to the given destination a sequence of 32-bit units that can be provided to the constructor of a second object of type S, and that would reproduce in that second object a state indistinguishable from the state of the first object.

29.5.3.3 Uniform random bit generator requirements [rand.req.urng]

1
#
A uniform random bit generator g of type G is a function object returning unsigned integer values such that each value in the range of possible results has (ideally) equal probability of being returned.
[Note 1: 
The degree to which g's results approximate the ideal is often determined statistically.
— end note]
template<class G> concept uniform_random_bit_generator = invocable<G&> && unsigned_integral<invoke_result_t<G&> && requires { { G::min() } -> same_as<invoke_result_t<G&>; { G::max() } -> same_as<invoke_result_t<G&>; requires bool_constant<(G::min() < G::max()>::value; };
2
#
Let g be an object of type G.
G models uniform_random_bit_generator only if
  • (2.1)
    G​::​min() <= g(),
  • (2.2)
    g() <= G​::​max(), and
  • (2.3)
    g() has amortized constant complexity.
3
#
A class G meets the uniform random bit generator requirements if G models uniform_random_bit_generator, invoke_result_t<G&> is an unsigned integer type ([basic.fundamental]), and G provides a nested typedef-name result_type that denotes the same type as invoke_result_t<G&>.

29.5.3.4 Random number engine requirements [rand.req.eng]

1
#
A random number engine (commonly shortened to engine) e of type E is a uniform random bit generator that additionally meets the requirements (e.g., for seeding and for input/output) specified in this subclause.
2
#
At any given time, e has a state e
Upon construction, e has an initial state e
An engine's state may be established via a constructor, a seed function, assignment, or a suitable operator>.
3
#
E's specification shall define:
4
#
A class E that meets the requirements of a uniform random bit generator also meets the requirements of a random number engine if the expressions shown in Table 127 are valid and have the indicated semantics, and if E also meets all other requirements of [rand.req.eng].
In Table 127 and throughout this subclause:
  • (4.1)
    T is the type named by E's associated result_type;
  • (4.2)
    e is a value of E, v is an lvalue of E, x and y are (possibly const) values of E;
  • (4.3)
    s is a value of T;
  • (4.4)
    q is an lvalue meeting the requirements of a seed sequence;
  • (4.5)
    z is a value of type unsigned long;
  • (4.6)
    os is an lvalue of the type of some class template specialization basic_ostream<charT, traits>; and
  • (4.7)
    is is an lvalue of the type of some class template specialization basic_istream<charT, traits>;
where charT and traits are constrained according to [strings] and [input.output].
Table 127 — Random number engine requirements [tab:rand.req.eng]
🔗
Expression
Return type
Pre/post-condition
Complexity
🔗
E()
Creates an engine with the same initial state as all other default-constructed engines of type E.
🔗
E(x)
Creates an engine that compares equal to x.
🔗
E(s)
Creates an engine with initial state determined by s.
🔗
E(q)232
Creates an engine with an initial state that depends on a sequence produced by one call to q.generate.
same as complexity of q.generate called on a sequence whose length is size of state
🔗
e.seed()
void
Postconditions: e == E().
same as E()
🔗
e.seed(s)
void
Postconditions: e == E(s).
same as E(s)
🔗
e.seed(q)
void
Postconditions: e == E(q).
same as E(q)
🔗
e()
T
Advances e's state e
🔗
e.discard(z)233
void
Advances e's state e
no worse than the complexity of z consecutive calls e()
🔗
x == y
bool
This operator is an equivalence relation.
With
🔗
x != y
bool
!(x == y).
5
#
E shall meet the Cpp17CopyConstructible (Table 32) and Cpp17CopyAssignable (Table 34) requirements.
These operations shall each be of complexity no worse than
6
#
On hosted implementations, the following expressions are well-formed and have the specified semantics.
🔗
os << x
7
#
Effects: With os.fmtflags set to ios_base​::​dec|ios_base​::​left and the fill character set to the space character, writes to os the textual representation of x's current state.
In the output, adjacent numbers are separated by one or more space characters.
8
#
Complexity:
🔗
is >> v
12
#
Preconditions: is provides a textual representation that was previously written using an output stream whose imbued locale was the same as that of is, and whose type's template specialization arguments charT and traits were respectively the same as those of is.
13
#
Effects: With is.fmtflags set to ios_base​::​dec, sets v's state as determined by reading its textual representation from is.
If bad input is encountered, ensures that v's state is unchanged by the operation and calls is.setstate(ios_base​::​failbit) (which may throw ios_base​::​failure ([iostate.flags])).
If a textual representation written via os << x was subsequently read via is >> v, then x == v provided that there have been no intervening invocations of x or of v.
14
#
Complexity:
232)232)
This constructor (as well as the subsequent corresponding seed() function) can be particularly useful to applications requiring a large number of independent random sequences.
233)233)
This operation is common in user code, and can often be implemented in an engine-specific manner so as to provide significant performance improvements over an equivalent naive loop that makes z consecutive calls e().

29.5.3.5 Random number engine adaptor requirements [rand.req.adapt]

1
#
A random number engine adaptor (commonly shortened to adaptor) a of type A is a random number engine that takes values produced by some other random number engine, and applies an algorithm to those values in order to deliver a sequence of values with different randomness properties.
An engine b of type B adapted in this way is termed a base engine in this context.
The expression a.base() shall be valid and shall return a const reference to a's base engine.
2
#
The requirements of a random number engine type shall be interpreted as follows with respect to a random number engine adaptor type.
🔗
A::A();
3
#
Effects: The base engine is initialized as if by its default constructor.
🔗
bool operator=(const A& a1, const A& a2);
4
#
Returns: true if a1's base engine is equal to a2's base engine.
Otherwise returns false.
🔗
A::A(result_type s);
5
#
Effects: The base engine is initialized with s.
🔗
template<class Sseq> A::A(Sseq& q);
6
#
Effects: The base engine is initialized with q.
🔗
void seed();
7
#
Effects: With b as the base engine, invokes b.seed().
🔗
void seed(result_type s);
8
#
Effects: With b as the base engine, invokes b.seed(s).
🔗
template<class Sseq> void seed(Sseq& q);
9
#
A shall also meet the following additional requirements:
  • (10.1)
    The complexity of each function shall not exceed the complexity of the corresponding function applied to the base engine.
  • (10.2)
    The state of A shall include the state of its base engine.
    The size of A's state shall be no less than the size of the base engine.
  • (10.3)
    Copying A's state (e.g., during copy construction or copy assignment) shall include copying the state of the base engine of A.
  • (10.4)
    The textual representation of A shall include the textual representation of its base engine.

29.5.3.6 Random number distribution requirements [rand.req.dist]

1
#
A random number distribution (commonly shortened to distribution) d of type D is a function object returning values that are distributed according to an associated mathematical probability density function p(z) or according to an associated discrete probability function
A distribution's specification identifies its associated probability function p(z) or
2
#
An associated probability function is typically expressed using certain externally-supplied quantities known as the parameters of the distribution.
Such distribution parameters are identified in this context by writing, for example, p(z | a,b) or
3
#
A class D meets the requirements of a random number distribution if the expressions shown in Table 128 are valid and have the indicated semantics, and if D and its associated types also meet all other requirements of [rand.req.dist].
In Table 128 and throughout this subclause,
  • (3.1)
    T is the type named by D's associated result_type;
  • (3.2)
    P is the type named by D's associated param_type;
  • (3.3)
    d is a value of D, and x and y are (possibly const) values of D;
  • (3.4)
    glb and lub are values of T respectively corresponding to the greatest lower bound and the least upper bound on the values potentially returned by d's operator(), as determined by the current values of d's parameters;
  • (3.5)
    p is a (possibly const) value of P;
  • (3.6)
    g, g1, and g2 are lvalues of a type meeting the requirements of a uniform random bit generator;
  • (3.7)
    os is an lvalue of the type of some class template specialization basic_ostream<charT, traits>; and
  • (3.8)
    is is an lvalue of the type of some class template specialization basic_istream<charT, traits>;
where charT and traits are constrained according to [strings] and [input.output].
Table 128 — Random number distribution requirements [tab:rand.req.dist]
🔗
Expression
Return type
Pre/post-condition
Complexity
🔗
D​::​result_type
T
🔗
D​::​param_type
P
🔗
D()
Creates a distribution whose behavior is indistinguishable from that of any other newly default-constructed distribution of type D.
constant
🔗
D(p)
Creates a distribution whose behavior is indistinguishable from that of a distribution newly constructed directly from the values used to construct p.
same as p's construction
🔗
d.reset()
void
Subsequent uses of d do not depend on values produced by any engine prior to invoking reset.
constant
🔗
x.param()
P
Returns a value p such that D(p).param() == p.
no worse than the complexity of D(p)
🔗
d.param(p)
void
Postconditions: d.param() == p.
no worse than the complexity of D(p)
🔗
d(g)
T
With
amortized constant number of invocations of g
🔗
d(g,p)
T
The sequence of numbers returned by successive invocations with the same objects g and p is randomly distributed according to the associated p(z |{p}) or
amortized constant number of invocations of g
🔗
x.min()
T
Returns glb.
constant
🔗
x.max()
T
Returns lub.
constant
🔗
x == y
bool
This operator is an equivalence relation.
Returns true if x.param() == y.param() and
Otherwise returns false.
constant
🔗
x != y
bool
!(x == y).
same as x == y.
4
#
D shall meet the Cpp17CopyConstructible (Table 32) and Cpp17CopyAssignable (Table 34) requirements.
5
#
The sequence of numbers produced by repeated invocations of d(g) shall be independent of any invocation of os << d or of any const member function of D between any of the invocations of d(g).
6
#
If a textual representation is written using os << x and that representation is restored into the same or a different object y of the same type using is >> y, repeated invocations of y(g) shall produce the same sequence of numbers as would repeated invocations of x(g).
7
#
It is unspecified whether D​::​param_type is declared as a (nested) class or via a typedef.
In [rand], declarations of D​::​param_type are in the form of typedefs for convenience of exposition only.
8
#
P shall meet the Cpp17CopyConstructible (Table 32), Cpp17CopyAssignable (Table 34), and Cpp17EqualityComparable (Table 28) requirements.
9
#
For each of the constructors of D taking arguments corresponding to parameters of the distribution, P shall have a corresponding constructor subject to the same requirements and taking arguments identical in number, type, and default values.
Moreover, for each of the member functions of D that return values corresponding to parameters of the distribution, P shall have a corresponding member function with the identical name, type, and semantics.
10
#
P shall have a declaration of the form using distribution_type = D;
11
#
On hosted implementations, the following expressions are well-formed and have the specified semantics.
🔗
os << x
12
#
Effects: Writes to os a textual representation for the parameters and the additional internal data of x.
13
#
Returns: os.
🔗
is >> d
16
#
Preconditions: is provides a textual representation that was previously written using an os whose imbued locale and whose type's template specialization arguments charT and traits were the same as those of is.
17
#
Effects: Restores from is the parameters and additional internal data of the lvalue d.
If bad input is encountered, ensures that d is unchanged by the operation and calls is.setstate(ios_base​::​failbit) (which may throw ios_base​::​failure ([iostate.flags])).
18
#
Each type instantiated from a class template specified in [rand.eng] meets the requirements of a random number engine type.
2
#
Except where specified otherwise, the complexity of each function specified in [rand.eng] is constant.
3
#
Except where specified otherwise, no function described in [rand.eng] throws an exception.
4
#
Every function described in [rand.eng] that has a function parameter q of type Sseq& for a template type parameter named Sseq that is different from type seed_seq throws what and when the invocation of q.generate throws.
5
#
Descriptions are provided in [rand.eng] only for engine operations that are not described in [rand.req.eng] or for operations where there is additional semantic information.
In particular, declarations for copy constructors, for copy assignment operators, for streaming operators, and for equality and inequality operators are not shown in the synopses.
6
#
Each template specified in [rand.eng] requires one or more relationships, involving the value(s) of its constant template parameter(s), to hold.
A program instantiating any of these templates is ill-formed if any such required relationship fails to hold.
7
#
For every random number engine and for every random number engine adaptor X defined in [rand.eng] and in [rand.adapt]:
  • (7.1)
    if the constructor template<class Sseq> explicit X(Sseq& q); is called with a type Sseq that does not qualify as a seed sequence, then this constructor shall not participate in overload resolution;
  • (7.2)
    if the member function template<class Sseq> void seed(Sseq& q); is called with a type Sseq that does not qualify as a seed sequence, then this function shall not participate in overload resolution.
The extent to which an implementation determines that a type cannot be a seed sequence is unspecified, except that as a minimum a type shall not qualify as a seed sequence if it is implicitly convertible to X​::​result_type.

29.5.4.2 Class template linear_congruential_engine [rand.eng.lcong]

1
#
A linear_congruential_engine random number engine produces unsigned integer random numbers.
The state x
The transition algorithm is a modular linear function of the form
🔗
namespace std { template<class UIntType, UIntType a, UIntType c, UIntType m> class linear_congruential_engine { public: / types using result_type = UIntType; / engine characteristics static constexpr result_type multiplier = a; static constexpr result_type increment = c; static constexpr result_type modulus = m; static constexpr result_type min() { return c == 0u ? 1u: 0u; } static constexpr result_type max() { return m - 1u; } static constexpr result_type default_seed = 1u; / constructors and seeding functions linear_congruential_engine() : linear_congruential_engine(default_seed) {} explicit linear_congruential_engine(result_type s); template<class Sseq> explicit linear_congruential_engine(Sseq& q); void seed(result_type s = default_seed); template<class Sseq> void seed(Sseq& q); / equality operators friend bool operator=(const linear_congruential_engine& x, const linear_congruential_engine& y); / generating functions result_type operator()(); void discard(unsigned long z); / inserters and extractors template<class charT, class traits> friend basic_ostream<charT, traits>& operator<(basic_ostream<charT, traits>& os, / hosted const linear_congruential_engine& x); template<class charT, class traits> friend basic_istream<charT, traits>& operator>(basic_istream<charT, traits>& is, / hosted linear_congruential_engine& x); }; }
2
#
If the template parameter m is 0, the modulus m used throughout [rand.eng.lcong] is numeric_limits<result_type>​::​max() plus 1.
[Note 1: 
m need not be representable as a value of type result_type.
— end note]
3
#
If the template parameter m is not 0, the following relations shall hold: a < m and c < m.
4
#
The textual representation consists of the value of x
🔗
explicit linear_congruential_engine(result_type s);
5
#
Effects: If
🔗
template<class Sseq> explicit linear_congruential_engine(Sseq& q);
6
#
Effects: With
If

29.5.4.3 Class template mersenne_twister_engine [rand.eng.mers]

1
#
A mersenne_twister_engine random number engine234 produces unsigned integer random numbers in the closed interval
The state x
2
#
The transition algorithm employs a twisted generalized feedback shift register defined by shift values n and m, a twist value r, and a conditional xor-mask a.
To improve the uniformity of the result, the bits of the raw shift register are additionally tempered (i.e., scrambled) according to a bit-scrambling matrix defined by values u, d, s, b, t, c, and ℓ.
The state transition is performed as follows:
  • (2.1)
    Concatenate the upper
  • (2.2)
    With
The sequence X is initialized with the help of an initialization multiplier f.
3
#
The generation algorithm determines the unsigned integer values
🔗
namespace std { template<class UIntType, size_t w, size_t n, size_t m, size_t r, UIntType a, size_t u, UIntType d, size_t s, UIntType b, size_t t, UIntType c, size_t l, UIntType f> class mersenne_twister_engine { public: / types using result_type = UIntType; / engine characteristics static constexpr size_t word_size = w; static constexpr size_t state_size = n; static constexpr size_t shift_size = m; static constexpr size_t mask_bits = r; static constexpr UIntType xor_mask = a; static constexpr size_t tempering_u = u; static constexpr UIntType tempering_d = d; static constexpr size_t tempering_s = s; static constexpr UIntType tempering_b = b; static constexpr size_t tempering_t = t; static constexpr UIntType tempering_c = c; static constexpr size_t tempering_l = l; static constexpr UIntType initialization_multiplier = f; static constexpr result_type min() { return 0; } static constexpr result_type max() { return
4
#
The following relations shall hold: 0 < m, m <= n, 2u < w, r <= w, u <= w, s <= w, t <= w, l <= w, w <= numeric_limits<UIntType>​::​digits, a <= (1u << w) - 1u, b <= (1u << w) - 1u, c <= (1u << w) - 1u, d <= (1u << w) - 1u, and f <= (1u << w) - 1u.
5
#
The textual representation of x
🔗
explicit mersenne_twister_engine(result_type value);
6
#
Effects: Sets
Then, iteratively for
7
#
Complexity:
🔗
template<class Sseq> explicit mersenne_twister_engine(Sseq& q);
8
#
Effects: With
Finally, if the most significant
234)234)
The name of this engine refers, in part, to a property of its period: For properly-selected values of the parameters, the period is closely related to a large Mersenne prime number.

29.5.4.4 Class template subtract_with_carry_engine [rand.eng.sub]

1
#
A subtract_with_carry_engine random number engine produces unsigned integer random numbers.
2
#
The state x
The state x
3
#
The state transition is performed as follows:
  • (3.1)
    Let
  • (3.2)
    Set
    Set c to 1 if
[Note 1: 
This algorithm corresponds to a modular linear function of the form
— end note]
4
#
The generation algorithm is given by
🔗
namespace std { template<class UIntType, size_t w, size_t s, size_t r> class subtract_with_carry_engine { public: / types using result_type = UIntType; / engine characteristics static constexpr size_t word_size = w; static constexpr size_t short_lag = s; static constexpr size_t long_lag = r; static constexpr result_type min() { return 0; } static constexpr result_type max() { return
5
#
The following relations shall hold: 0u < s, s < r, 0 < w, and w <= numeric_limits<UIntType>​::​digits.
6
#
The textual representation consists of the values of
🔗
explicit subtract_with_carry_engine(result_type value);
7
#
Effects: Sets the values of
If
To set the values
Then, to set each
Set
8
#
Complexity: Exactly
🔗
template<class Sseq> explicit subtract_with_carry_engine(Sseq& q);
9
#
Effects: With
If

29.5.4.5 Class template philox_engine [rand.eng.philox]

1
#
A philox_engine random number engine produces unsigned integer random numbers in the interval [0, m), where
The state of a philox_engine object consists of a sequence X of n unsigned integer values of width w, a sequence K of
2
#
The generation algorithm returns
3
#
The state transition is performed as if by the following algorithm: i = i + 1 if (i == n) { Y = Philox(K, X) / see below Z = Z + 1 i = 0 }
4
#
The Philox function maps the length-
Philox applies an r-round substitution-permutation network to the values in X.
A single round of the generation algorithm performs the following steps:
  • (4.1)
    The output sequence
  • (4.2)
    The following computations are applied to the elements of the V sequence:
5
#
After r applications of the single-round function, Philox returns the sequence
🔗
namespace std { template<class UIntType, size_t w, size_t n, size_t r, UIntType.. consts> class philox_engine { static constexpr size_t array-size = n / 2; / exposition only public: / types using result_type = UIntType; / engine characteristics static constexpr size_t word_size = w; static constexpr size_t word_count = n; static constexpr size_t round_count = r; static constexpr array<result_type, array-size> multipliers; static constexpr array<result_type, array-size> round_consts; static constexpr result_type min() { return 0; } static constexpr result_type max() { return m - 1; } static constexpr result_type default_seed = 20111115u; / constructors and seeding functions philox_engine() : philox_engine(default_seed) {} explicit philox_engine(result_type value); template<class Sseq> explicit philox_engine(Sseq& q); void seed(result_type value = default_seed); template<class Sseq> void seed(Sseq& q); void set_counter(const array<result_type, n>& counter); / equality operators friend bool operator=(const philox_engine& x, const philox_engine& y); / generating functions result_type operator()(); void discard(unsigned long z); / inserters and extractors template<class charT, class traits> friend basic_ostream<charT, traits>& operator<(basic_ostream<charT, traits>& os, const philox_engine& x); / hosted template<class charT, class traits> friend basic_istream<charT, traits>& operator>(basic_istream<charT, traits>& is, philox_engine& x); / hosted }; }
6
#
The template parameter pack consts represents the
8
#
The textual representation consists of the values of
[Note 2: 
The stream extraction operator can reconstruct Y from K and X, as needed.
— end note]
🔗
explicit philox_engine(result_type value);
9
#
Effects: Sets the
All elements of sequences X and K (except
The value of i is set to
🔗
template<class Sseq> explicit philox_engine(Sseq& q);
10
#
Effects: With
All elements of sequence X are set to 0.
The value of i is set to
🔗
void set_counter(const array<result_type, n>& c);
11
#
Each type instantiated from a class template specified in [rand.adapt] meets the requirements of a random number engine adaptor type.
2
#
Except where specified otherwise, the complexity of each function specified in [rand.adapt] is constant.
3
#
Except where specified otherwise, no function described in [rand.adapt] throws an exception.
4
#
Every function described in [rand.adapt] that has a function parameter q of type Sseq& for a template type parameter named Sseq that is different from type seed_seq throws what and when the invocation of q.generate throws.
5
#
Descriptions are provided in [rand.adapt] only for adaptor operations that are not described in subclause [rand.req.adapt] or for operations where there is additional semantic information.
In particular, declarations for copy constructors, for copy assignment operators, for streaming operators, and for equality and inequality operators are not shown in the synopses.
6
#
Each template specified in [rand.adapt] requires one or more relationships, involving the value(s) of its constant template parameter(s), to hold.
A program instantiating any of these templates is ill-formed if any such required relationship fails to hold.

29.5.5.2 Class template discard_block_engine [rand.adapt.disc]

1
#
A discard_block_engine random number engine adaptor produces random numbers selected from those produced by some base engine e.
The state x
The size of the state is the size of e's state plus 1.
2
#
The transition algorithm discards all but
The state transition is performed as follows: If n  ≥ r, advance the state of e from e
In any case, then increment n and advance e's then-current state e
3
#
The generation algorithm yields the value returned by the last invocation of e() while advancing e's state as described above.
🔗
namespace std { template<class Engine, size_t p, size_t r> class discard_block_engine { public: / types using result_type = Engine::result_type; / engine characteristics static constexpr size_t block_size = p; static constexpr size_t used_block = r; static constexpr result_type min() { return Engine::min(); } static constexpr result_type max() { return Engine::max(); } / constructors and seeding functions discard_block_engine(); explicit discard_block_engine(const Engine& e); explicit discard_block_engine(Engine&& e); explicit discard_block_engine(result_type s); template<class Sseq> explicit discard_block_engine(Sseq& q); void seed(); void seed(result_type s); template<class Sseq> void seed(Sseq& q); / equality operators friend bool operator=(const discard_block_engine& x, const discard_block_engine& y); / generating functions result_type operator()(); void discard(unsigned long z); / property functions const Engine& base() const noexcept { return e; } / inserters and extractors template<class charT, class traits> friend basic_ostream<charT, traits>& operator<(basic_ostream<charT, traits>& os, const discard_block_engine& x); / hosted template<class charT, class traits> friend basic_istream<charT, traits>& operator>(basic_istream<charT, traits>& is, discard_block_engine& x); / hosted private: Engine e; / exposition only size_t n; / exposition only }; }
4
#
The following relations shall hold: 0 < r and r <= p.
5
#
The textual representation consists of the textual representation of e followed by the value of n.
6
#
In addition to its behavior pursuant to subclause [rand.req.adapt], each constructor that is not a copy constructor sets n to 0.

29.5.5.3 Class template independent_bits_engine [rand.adapt.ibits]

1
#
An independent_bits_engine random number engine adaptor combines random numbers that are produced by some base engine e, so as to produce random numbers with a specified number of bits w.
The state x
2
#
The transition and generation algorithms are described in terms of the following integral constants:
  • (2.1)
    Let
  • (2.2)
    With n as determined below, let
  • (2.3)
    Let
    Otherwise let
[Note 1: 
The relation
— end note]
3
#
The transition algorithm is carried out by invoking e() as often as needed to obtain
4
#
The generation algorithm uses the values produced while advancing the state as described above to yield a quantity S obtained as if by the following algorithm: S = 0; for (k = 0;
🔗
namespace std { template<class Engine, size_t w, class UIntType> class independent_bits_engine { public: / types using result_type = UIntType; / engine characteristics static constexpr result_type min() { return 0; } static constexpr result_type max() { return
5
#
The following relations shall hold: 0 < w and w <= numeric_limits<result_type>​::​digits.
6
#
The textual representation consists of the textual representation of e.

29.5.5.4 Class template shuffle_order_engine [rand.adapt.shuf]

1
#
A shuffle_order_engine random number engine adaptor produces the same random numbers that are produced by some base engine e, but delivers them in a different sequence.
The state x
The size of the state is the size of e's state plus
2
#
The transition algorithm permutes the values produced by e.
The state transition is performed as follows:
  • (2.1)
    Calculate an integer
  • (2.2)
    Set Y to
3
#
The generation algorithm yields the last value of Y produced while advancing e's state as described above.
🔗
namespace std { template<class Engine, size_t k> class shuffle_order_engine { public: / types using result_type = Engine::result_type; / engine characteristics static constexpr size_t table_size = k; static constexpr result_type min() { return Engine::min(); } static constexpr result_type max() { return Engine::max(); } / constructors and seeding functions shuffle_order_engine(); explicit shuffle_order_engine(const Engine& e); explicit shuffle_order_engine(Engine&& e); explicit shuffle_order_engine(result_type s); template<class Sseq> explicit shuffle_order_engine(Sseq& q); void seed(); void seed(result_type s); template<class Sseq> void seed(Sseq& q); / equality operators friend bool operator=(const shuffle_order_engine& x, const shuffle_order_engine& y); / generating functions result_type operator()(); void discard(unsigned long z); / property functions const Engine& base() const noexcept { return e; } / inserters and extractors template<class charT, class traits> friend basic_ostream<charT, traits>& operator<(basic_ostream<charT, traits>& os, const shuffle_order_engine& x); template<class charT, class traits> friend basic_istream<charT, traits>& operator>(basic_istream<charT, traits>& is, shuffle_order_engine& x); private: Engine e; / exposition only result_type V[k]; / exposition only result_type Y; / exposition only }; }
4
#
The following relation shall hold: 0 < k.
5
#
The textual representation consists of the textual representation of e, followed by the k values of V, followed by the value of Y.
6
#
In addition to its behavior pursuant to subclause [rand.req.adapt], each constructor that is not a copy constructor initializes V[0], …, V[k - 1] and Y, in that order, with values returned by successive invocations of e().

29.5.6 Engines and engine adaptors with predefined parameters [rand.predef]

🔗
using minstd_rand0 = linear_congruential_engine<uint_fast32_t, 16'807, 0, 2'147'483'647>;
1
#
Required behavior: The
🔗
using minstd_rand = linear_congruential_engine<uint_fast32_t, 48'271, 0, 2'147'483'647>;
2
#
Required behavior: The
🔗
using mt19937 = mersenne_twister_engine<uint_fast32_t, 32, 624, 397, 31, 0x9908'b0df, 11, 0xffff'ffff, 7, 0x9d2c'5680, 15, 0xefc6'0000, 18, 1'812'433'253>;
3
#
Required behavior: The
🔗
using mt19937_64 = mersenne_twister_engine<uint_fast64_t, 64, 312, 156, 31, 0xb502'6f5a'a966'19e9, 29, 0x5555'5555'5555'5555, 17, 0x71d6'7fff'eda6'0000, 37, 0xfff7'eee0'0000'0000, 43, 6'364'136'223'846'793'005>;
4
#
Required behavior: The
🔗
using ranlux24_base = subtract_with_carry_engine<uint_fast32_t, 24, 10, 24>;
5
#
Required behavior: The
🔗
using ranlux48_base = subtract_with_carry_engine<uint_fast64_t, 48, 5, 12>;
6
#
Required behavior: The
🔗
using ranlux24 = discard_block_engine<ranlux24_base, 223, 23>;
7
#
Required behavior: The
🔗
using ranlux48 = discard_block_engine<ranlux48_base, 389, 11>;
8
#
Required behavior: The
🔗
using knuth_b = shuffle_order_engine<minstd_rand0,256>;
9
#
Required behavior: The
🔗
using default_random_engine = implementation-defined;
10
#
Remarks: The choice of engine type named by this typedef is implementation-defined.
[Note 1: 
The implementation can select this type on the basis of performance, size, quality, or any combination of such factors, so as to provide at least acceptable engine behavior for relatively casual, inexpert, and/or lightweight use.
Because different implementations can select different underlying engine types, code that uses this typedef need not generate identical sequences across implementations.
— end note]
🔗
using philox4x32 = philox_engine<uint_fast32_t, 32, 4, 10, 0xCD9E8D57, 0x9E3779B9, 0xD2511F53, 0xBB67AE85>;
11
#
Required behavior: The
🔗
using philox4x64 = philox_engine<uint_fast64_t, 64, 4, 10, 0xCA5A826395121157, 0x9E3779B97F4A7C15, 0xD2E7470EE14C6C93, 0xBB67AE8584CAA73B>;
12
#
Required behavior: The

29.5.7 Class random_device [rand.device]

1
#
A random_device uniform random bit generator produces nondeterministic random numbers.
2
#
If implementation limitations prevent generating nondeterministic random numbers, the implementation may employ a random number engine.
🔗
namespace std { class random_device { public: / types using result_type = unsigned int; / generator characteristics static constexpr result_type min() { return numeric_limits<result_type>::min(); } static constexpr result_type max() { return numeric_limits<result_type>::max(); } / constructors random_device() : random_device(implementation-defined) {} explicit random_device(const string& token); / generating functions result_type operator()(); / property functions double entropy() const noexcept; / no copy functions random_device(const random_device&) = delete; void operator=(const random_device&) = delete; }; }
🔗
explicit random_device(const string& token);
3
#
Throws: A value of an implementation-defined type derived from exception if the random_device cannot be initialized.
4
#
Remarks: The semantics of the token parameter and the token value used by the default constructor are implementation-defined.235
🔗
double entropy() const noexcept;
5
#
Returns: If the implementation employs a random number engine, returns 0.0.
Otherwise, returns an entropy estimate236 for the random numbers returned by operator(), in the range min() to
🔗
result_type operator()();
6
#
Returns: A nondeterministic random value, uniformly distributed between min() and max() (inclusive).
It is implementation-defined how these values are generated.
7
#
Throws: A value of an implementation-defined type derived from exception if a random number cannot be obtained.
235)235)
The parameter is intended to allow an implementation to differentiate between different sources of randomness.
236)236)
If a device has n states whose respective probabilities are
🔗
namespace std { class seed_seq { public: / types using result_type = uint_least32_t; / constructors seed_seq() noexcept; template<class T> seed_seq(initializer_list<T> il); template<class InputIterator> seed_seq(InputIterator begin, InputIterator end); / generating functions template<class RandomAccessIterator> void generate(RandomAccessIterator begin, RandomAccessIterator end); / property functions size_t size() const noexcept; template<class OutputIterator> void param(OutputIterator dest) const; / no copy functions seed_seq(const seed_seq&) = delete; void operator=(const seed_seq&) = delete; private: vector<result_type> v; / exposition only }; }
🔗
seed_seq() noexcept;
1
#
Postconditions: v.empty() is true.
🔗
template<class T> seed_seq(initializer_list<T> il);
2
#
Effects: Same as seed_seq(il.begin(), il.end().
🔗
template<class InputIterator> seed_seq(InputIterator begin, InputIterator end);
4
#
Mandates: iterator_traits<InputIterator>​::​value_type is an integer type.
5
#
Preconditions: InputIterator meets the Cpp17InputIterator requirements ([input.iterators]).
6
#
Effects: Initializes v by the following algorithm: for (InputIterator s = begin; s != end; ++s) v.push_back((*s)
🔗
template<class RandomAccessIterator> void generate(RandomAccessIterator begin, RandomAccessIterator end);
7
#
Mandates: iterator_traits<RandomAccessIterator>​::​​value_type is an unsigned integer type capable of accommodating 32-bit quantities.
8
#
Preconditions: RandomAccessIterator meets the Cpp17RandomAccessIterator requirements ([random.access.iterators]) and the requirements of a mutable iterator.
9
#
Effects: Does nothing if begin == end.
Otherwise, with
10
#
Throws: What and when RandomAccessIterator operations of begin and end throw.
🔗
size_t size() const noexcept;
11
#
Returns: The number of 32-bit units that would be returned by a call to param().
12
#
Complexity: Constant time.
🔗
template<class OutputIterator> void param(OutputIterator dest) const;
13
#
Preconditions: OutputIterator meets the Cpp17OutputIterator requirements ([output.iterators]).
15
#
Effects: Copies the sequence of prepared 32-bit units to the given destination, as if by executing the following statement: copy(v.begin(), v.end(), dest);
16
#
Throws: What and when OutputIterator operations of dest throw.

29.5.8.2 Function template generate_canonical [rand.util.canonical]

🔗
template<class RealType, size_t digits, class URBG> RealType generate_canonical(URBG& g);
1
#
Let
  • (1.1)
    r be numeric_limits<RealType>​::​radix,
  • (1.2)
    R be
  • (1.3)
    d be the smaller of digits and numeric_limits<RealType>​::​digits,237
  • (1.4)
    k be the smallest integer such that
  • (1.5)
    x be
An attempt is k invocations of g() to obtain values
2
#
Returns:
[Note 2: 
The return value c satisfies
— end note]
4
#
[Note 3: 
If the values
Obtaining a value in this way can be a useful step in the process of transforming a value generated by a uniform random bit generator into a value that can be delivered by a random number distribution.
— end note]
7
#
[Note 4: 
When R is a power of r, an implementation can avoid using an arithmetic type that is wider than the output when computing S.
— end note]
237)237)
d is introduced to avoid any attempt to produce more bits of randomness than can be held in RealType.

29.5.9 Random number distribution class templates [rand.dist]

1
#
Each type instantiated from a class template specified in [rand.dist] meets the requirements of a random number distribution type.
2
#
Descriptions are provided in [rand.dist] only for distribution operations that are not described in [rand.req.dist] or for operations where there is additional semantic information.
In particular, declarations for copy constructors, for copy assignment operators, for streaming operators, and for equality and inequality operators are not shown in the synopses.
3
#
The algorithms for producing each of the specified distributions are implementation-defined.
4
#
The value of each probability density function p(z) and of each discrete probability function

29.5.9.2 Uniform distributions [rand.dist.uni]

29.5.9.2.1 Class template uniform_int_distribution [rand.dist.uni.int]

1
#
A uniform_int_distribution random number distribution produces random integers i, a  ≤ i  ≤ b, distributed according to the constant discrete probability function in Formula 29.2.
🔗
namespace std { template<class IntType = int> class uniform_int_distribution { public: / types using result_type = IntType; using param_type = unspecified; / constructors and reset functions uniform_int_distribution() : uniform_int_distribution(0) {} explicit uniform_int_distribution(IntType a, IntType b = numeric_limits<IntType>::max(); explicit uniform_int_distribution(const param_type& parm); void reset(); / equality operators friend bool operator=(const uniform_int_distribution& x, const uniform_int_distribution& y); / generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); / property functions result_type a() const; result_type b() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; / inserters and extractors template<class charT, class traits> friend basic_ostream<charT, traits>& operator<(basic_ostream<charT, traits>& os, / hosted const uniform_int_distribution& x); template<class charT, class traits> friend basic_istream<charT, traits>& operator>(basic_istream<charT, traits>& is, / hosted uniform_int_distribution& x); }; }
🔗
explicit uniform_int_distribution(IntType a, IntType b = numeric_limits<IntType>::max();
2
#
Remarks: a and b correspond to the respective parameters of the distribution.
🔗
result_type a() const;
4
#
Returns: The value of the a parameter with which the object was constructed.
🔗
result_type b() const;
5
#
Returns: The value of the b parameter with which the object was constructed.

29.5.9.2.2 Class template uniform_real_distribution [rand.dist.uni.real]

1
#
A uniform_real_distribution random number distribution produces random numbers x,
[Note 1: 
This implies that p(x | a,b) is undefined when a == b.
— end note]
🔗
namespace std { template<class RealType = double> class uniform_real_distribution { public: / types using result_type = RealType; using param_type = unspecified; / constructors and reset functions uniform_real_distribution() : uniform_real_distribution(0.0) {} explicit uniform_real_distribution(RealType a, RealType b = 1.0); explicit uniform_real_distribution(const param_type& parm); void reset(); / equality operators friend bool operator=(const uniform_real_distribution& x, const uniform_real_distribution& y); / generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); / property functions result_type a() const; result_type b() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; / inserters and extractors template<class charT, class traits> friend basic_ostream<charT, traits>& operator<(basic_ostream<charT, traits>& os, const uniform_real_distribution& x); template<class charT, class traits> friend basic_istream<charT, traits>& operator>(basic_istream<charT, traits>& is, uniform_real_distribution& x); }; }
🔗
explicit uniform_real_distribution(RealType a, RealType b = 1.0);
2
#
Preconditions: a  ≤ b and
3
#
Remarks: a and b correspond to the respective parameters of the distribution.
🔗
result_type a() const;
4
#
Returns: The value of the a parameter with which the object was constructed.
🔗
result_type b() const;
5
#
Returns: The value of the b parameter with which the object was constructed.

29.5.9.3 Bernoulli distributions [rand.dist.bern]

29.5.9.3.1 Class bernoulli_distribution [rand.dist.bern.bernoulli]

1
#
A bernoulli_distribution random number distribution produces bool values b distributed according to the discrete probability function in Formula 29.4.
🔗
namespace std { class bernoulli_distribution { public: / types using result_type = bool; using param_type = unspecified; / constructors and reset functions bernoulli_distribution() : bernoulli_distribution(0.5) {} explicit bernoulli_distribution(double p); explicit bernoulli_distribution(const param_type& parm); void reset(); / equality operators friend bool operator=(const bernoulli_distribution& x, const bernoulli_distribution& y); / generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); / property functions double p() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; / inserters and extractors template<class charT, class traits> friend basic_ostream<charT, traits>& operator<(basic_ostream<charT, traits>& os, const bernoulli_distribution& x); template<class charT, class traits> friend basic_istream<charT, traits>& operator>(basic_istream<charT, traits>& is, bernoulli_distribution& x); }; }
🔗
explicit bernoulli_distribution(double p);
2
#
Remarks: p corresponds to the parameter of the distribution.
🔗
double p() const;
4
#
Returns: The value of the p parameter with which the object was constructed.

29.5.9.3.2 Class template binomial_distribution [rand.dist.bern.bin]

1
#
A binomial_distribution random number distribution produces integer values i  ≥ 0 distributed according to the discrete probability function in Formula 29.5.
🔗
namespace std { template<class IntType = int> class binomial_distribution { public: / types using result_type = IntType; using param_type = unspecified; / constructors and reset functions binomial_distribution() : binomial_distribution(1) {} explicit binomial_distribution(IntType t, double p = 0.5); explicit binomial_distribution(const param_type& parm); void reset(); / equality operators friend bool operator=(const binomial_distribution& x, const binomial_distribution& y); / generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); / property functions IntType t() const; double p() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; / inserters and extractors template<class charT, class traits> friend basic_ostream<charT, traits>& operator<(basic_ostream<charT, traits>& os, const binomial_distribution& x); template<class charT, class traits> friend basic_istream<charT, traits>& operator>(basic_istream<charT, traits>& is, binomial_distribution& x); }; }
🔗
explicit binomial_distribution(IntType t, double p = 0.5);
2
#
Remarks: t and p correspond to the respective parameters of the distribution.
🔗
IntType t() const;
4
#
Returns: The value of the t parameter with which the object was constructed.
🔗
double p() const;
5
#
Returns: The value of the p parameter with which the object was constructed.

29.5.9.3.3 Class template geometric_distribution [rand.dist.bern.geo]

1
#
A geometric_distribution random number distribution produces integer values i  ≥ 0 distributed according to the discrete probability function in Formula 29.6.
🔗
namespace std { template<class IntType = int> class geometric_distribution { public: / types using result_type = IntType; using param_type = unspecified; / constructors and reset functions geometric_distribution() : geometric_distribution(0.5) {} explicit geometric_distribution(double p); explicit geometric_distribution(const param_type& parm); void reset(); / equality operators friend bool operator=(const geometric_distribution& x, const geometric_distribution& y); / generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); / property functions double p() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; / inserters and extractors template<class charT, class traits> friend basic_ostream<charT, traits>& operator<(basic_ostream<charT, traits>& os, const geometric_distribution& x); template<class charT, class traits> friend basic_istream<charT, traits>& operator>(basic_istream<charT, traits>& is, geometric_distribution& x); }; }
🔗
explicit geometric_distribution(double p);
2
#
Remarks: p corresponds to the parameter of the distribution.
🔗
double p() const;
4
#
Returns: The value of the p parameter with which the object was constructed.

29.5.9.3.4 Class template negative_binomial_distribution [rand.dist.bern.negbin]

1
#
A negative_binomial_distribution random number distribution produces random integers i  ≥ 0 distributed according to the discrete probability function in Formula 29.7.
[Note 1: 
This implies that P(i | k,p) is undefined when p == 1.
— end note]
🔗
namespace std { template<class IntType = int> class negative_binomial_distribution { public: / types using result_type = IntType; using param_type = unspecified; / constructor and reset functions negative_binomial_distribution() : negative_binomial_distribution(1) {} explicit negative_binomial_distribution(IntType k, double p = 0.5); explicit negative_binomial_distribution(const param_type& parm); void reset(); / equality operators friend bool operator=(const negative_binomial_distribution& x, const negative_binomial_distribution& y); / generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); / property functions IntType k() const; double p() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; / inserters and extractors template<class charT, class traits> friend basic_ostream<charT, traits>& operator<(basic_ostream<charT, traits>& os, const negative_binomial_distribution& x); template<class charT, class traits> friend basic_istream<charT, traits>& operator>(basic_istream<charT, traits>& is, negative_binomial_distribution& x); }; }
🔗
explicit negative_binomial_distribution(IntType k, double p = 0.5);
2
#
Preconditions:
3
#
Remarks: k and p correspond to the respective parameters of the distribution.
🔗
IntType k() const;
4
#
Returns: The value of the k parameter with which the object was constructed.
🔗
double p() const;
5
#
Returns: The value of the p parameter with which the object was constructed.

29.5.9.4 Poisson distributions [rand.dist.pois]

29.5.9.4.1 Class template poisson_distribution [rand.dist.pois.poisson]

1
#
A poisson_distribution random number distribution produces integer values i  ≥ 0 distributed according to the discrete probability function in Formula 29.8.
The distribution parameter μ is also known as this distribution's mean.
🔗
namespace std { template<class IntType = int> class poisson_distribution { public: / types using result_type = IntType; using param_type = unspecified; / constructors and reset functions poisson_distribution() : poisson_distribution(1.0) {} explicit poisson_distribution(double mean); explicit poisson_distribution(const param_type& parm); void reset(); / equality operators friend bool operator=(const poisson_distribution& x, const poisson_distribution& y); / generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); / property functions double mean() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; / inserters and extractors template<class charT, class traits> friend basic_ostream<charT, traits>& operator<(basic_ostream<charT, traits>& os, const poisson_distribution& x); template<class charT, class traits> friend basic_istream<charT, traits>& operator>(basic_istream<charT, traits>& is, poisson_distribution& x); }; }
🔗
explicit poisson_distribution(double mean);
2
#
Remarks: mean corresponds to the parameter of the distribution.
🔗
double mean() const;
4
#
Returns: The value of the mean parameter with which the object was constructed.

29.5.9.4.2 Class template exponential_distribution [rand.dist.pois.exp]

1
#
An exponential_distribution random number distribution produces random numbers
🔗
namespace std { template<class RealType = double> class exponential_distribution { public: / types using result_type = RealType; using param_type = unspecified; / constructors and reset functions exponential_distribution() : exponential_distribution(1.0) {} explicit exponential_distribution(RealType lambda); explicit exponential_distribution(const param_type& parm); void reset(); / equality operators friend bool operator=(const exponential_distribution& x, const exponential_distribution& y); / generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); / property functions RealType lambda() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; / inserters and extractors template<class charT, class traits> friend basic_ostream<charT, traits>& operator<(basic_ostream<charT, traits>& os, const exponential_distribution& x); template<class charT, class traits> friend basic_istream<charT, traits>& operator>(basic_istream<charT, traits>& is, exponential_distribution& x); }; }
🔗
explicit exponential_distribution(RealType lambda);
2
#
Remarks: lambda corresponds to the parameter of the distribution.
🔗
RealType lambda() const;
4
#
Returns: The value of the lambda parameter with which the object was constructed.

29.5.9.4.3 Class template gamma_distribution [rand.dist.pois.gamma]

1
#
A gamma_distribution random number distribution produces random numbers
🔗
namespace std { template<class RealType = double> class gamma_distribution { public: / types using result_type = RealType; using param_type = unspecified; / constructors and reset functions gamma_distribution() : gamma_distribution(1.0) {} explicit gamma_distribution(RealType alpha, RealType beta = 1.0); explicit gamma_distribution(const param_type& parm); void reset(); / equality operators friend bool operator=(const gamma_distribution& x, const gamma_distribution& y); / generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); / property functions RealType alpha() const; RealType beta() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; / inserters and extractors template<class charT, class traits> friend basic_ostream<charT, traits>& operator<(basic_ostream<charT, traits>& os, const gamma_distribution& x); template<class charT, class traits> friend basic_istream<charT, traits>& operator>(basic_istream<charT, traits>& is, gamma_distribution& x); }; }
🔗
explicit gamma_distribution(RealType alpha, RealType beta = 1.0);
2
#
Remarks: alpha and beta correspond to the parameters of the distribution.
🔗
RealType alpha() const;
4
#
Returns: The value of the alpha parameter with which the object was constructed.
🔗
RealType beta() const;
5
#
Returns: The value of the beta parameter with which the object was constructed.

29.5.9.4.4 Class template weibull_distribution [rand.dist.pois.weibull]

1
#
A weibull_distribution random number distribution produces random numbers x  ≥ 0 distributed according to the probability density function in Formula 29.11.
🔗
namespace std { template<class RealType = double> class weibull_distribution { public: / types using result_type = RealType; using param_type = unspecified; / constructor and reset functions weibull_distribution() : weibull_distribution(1.0) {} explicit weibull_distribution(RealType a, RealType b = 1.0); explicit weibull_distribution(const param_type& parm); void reset(); / equality operators friend bool operator=(const weibull_distribution& x, const weibull_distribution& y); / generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); / property functions RealType a() const; RealType b() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; / inserters and extractors template<class charT, class traits> friend basic_ostream<charT, traits>& operator<(basic_ostream<charT, traits>& os, const weibull_distribution& x); template<class charT, class traits> friend basic_istream<charT, traits>& operator>(basic_istream<charT, traits>& is, weibull_distribution& x); }; }
🔗
explicit weibull_distribution(RealType a, RealType b = 1.0);
2
#
Remarks: a and b correspond to the respective parameters of the distribution.
🔗
RealType a() const;
4
#
Returns: The value of the a parameter with which the object was constructed.
🔗
RealType b() const;
5
#
Returns: The value of the b parameter with which the object was constructed.

29.5.9.4.5 Class template extreme_value_distribution [rand.dist.pois.extreme]

1
#
An extreme_value_distribution random number distribution produces random numbers x distributed according to the probability density function in Formula 29.12.238
🔗
namespace std { template<class RealType = double> class extreme_value_distribution { public: / types using result_type = RealType; using param_type = unspecified; / constructor and reset functions extreme_value_distribution() : extreme_value_distribution(0.0) {} explicit extreme_value_distribution(RealType a, RealType b = 1.0); explicit extreme_value_distribution(const param_type& parm); void reset(); / equality operators friend bool operator=(const extreme_value_distribution& x, const extreme_value_distribution& y); / generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); / property functions RealType a() const; RealType b() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; / inserters and extractors template<class charT, class traits> friend basic_ostream<charT, traits>& operator<(basic_ostream<charT, traits>& os, const extreme_value_distribution& x); template<class charT, class traits> friend basic_istream<charT, traits>& operator>(basic_istream<charT, traits>& is, extreme_value_distribution& x); }; }
🔗
explicit extreme_value_distribution(RealType a, RealType b = 1.0);
2
#
Remarks: a and b correspond to the respective parameters of the distribution.
🔗
RealType a() const;
4
#
Returns: The value of the a parameter with which the object was constructed.
🔗
RealType b() const;
5
#
Returns: The value of the b parameter with which the object was constructed.
238)238)
The distribution corresponding to this probability density function is also known (with a possible change of variable) as the Gumbel Type I, the log-Weibull, or the Fisher-Tippett Type I distribution.

29.5.9.5 Normal distributions [rand.dist.norm]

29.5.9.5.1 Class template normal_distribution [rand.dist.norm.normal]

1
#
A normal_distribution random number distribution produces random numbers x distributed according to the probability density function in Formula 29.13.
The distribution parameters μ and σ are also known as this distribution's mean and standard deviation.
🔗
namespace std { template<class RealType = double> class normal_distribution { public: / types using result_type = RealType; using param_type = unspecified; / constructors and reset functions normal_distribution() : normal_distribution(0.0) {} explicit normal_distribution(RealType mean, RealType stddev = 1.0); explicit normal_distribution(const param_type& parm); void reset(); / equality operators friend bool operator=(const normal_distribution& x, const normal_distribution& y); / generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); / property functions RealType mean() const; RealType stddev() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; / inserters and extractors template<class charT, class traits> friend basic_ostream<charT, traits>& operator<(basic_ostream<charT, traits>& os, const normal_distribution& x); template<class charT, class traits> friend basic_istream<charT, traits>& operator>(basic_istream<charT, traits>& is, normal_distribution& x); }; }
🔗
explicit normal_distribution(RealType mean, RealType stddev = 1.0);
2
#
Remarks: mean and stddev correspond to the respective parameters of the distribution.
🔗
RealType mean() const;
4
#
Returns: The value of the mean parameter with which the object was constructed.
🔗
RealType stddev() const;
5
#
Returns: The value of the stddev parameter with which the object was constructed.

29.5.9.5.2 Class template lognormal_distribution [rand.dist.norm.lognormal]

1
#
A lognormal_distribution random number distribution produces random numbers
🔗
namespace std { template<class RealType = double> class lognormal_distribution { public: / types using result_type = RealType; using param_type = unspecified; / constructor and reset functions lognormal_distribution() : lognormal_distribution(0.0) {} explicit lognormal_distribution(RealType m, RealType s = 1.0); explicit lognormal_distribution(const param_type& parm); void reset(); / equality operators friend bool operator=(const lognormal_distribution& x, const lognormal_distribution& y); / generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); / property functions RealType m() const; RealType s() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; / inserters and extractors template<class charT, class traits> friend basic_ostream<charT, traits>& operator<(basic_ostream<charT, traits>& os, const lognormal_distribution& x); template<class charT, class traits> friend basic_istream<charT, traits>& operator>(basic_istream<charT, traits>& is, lognormal_distribution& x); }; }
🔗
explicit lognormal_distribution(RealType m, RealType s = 1.0);
2
#
Remarks: m and s correspond to the respective parameters of the distribution.
🔗
RealType m() const;
4
#
Returns: The value of the m parameter with which the object was constructed.
🔗
RealType s() const;
5
#
Returns: The value of the s parameter with which the object was constructed.

29.5.9.5.3 Class template chi_squared_distribution [rand.dist.norm.chisq]

1
#
A chi_squared_distribution random number distribution produces random numbers
🔗
namespace std { template<class RealType = double> class chi_squared_distribution { public: / types using result_type = RealType; using param_type = unspecified; / constructor and reset functions chi_squared_distribution() : chi_squared_distribution(1.0) {} explicit chi_squared_distribution(RealType n); explicit chi_squared_distribution(const param_type& parm); void reset(); / equality operators friend bool operator=(const chi_squared_distribution& x, const chi_squared_distribution& y); / generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); / property functions RealType n() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; / inserters and extractors template<class charT, class traits> friend basic_ostream<charT, traits>& operator<(basic_ostream<charT, traits>& os, const chi_squared_distribution& x); template<class charT, class traits> friend basic_istream<charT, traits>& operator>(basic_istream<charT, traits>& is, chi_squared_distribution& x); }; }
🔗
explicit chi_squared_distribution(RealType n);
2
#
Remarks: n corresponds to the parameter of the distribution.
🔗
RealType n() const;
4
#
Returns: The value of the n parameter with which the object was constructed.

29.5.9.5.4 Class template cauchy_distribution [rand.dist.norm.cauchy]

1
#
A cauchy_distribution random number distribution produces random numbers x distributed according to the probability density function in Formula 29.16.
🔗
namespace std { template<class RealType = double> class cauchy_distribution { public: / types using result_type = RealType; using param_type = unspecified; / constructor and reset functions cauchy_distribution() : cauchy_distribution(0.0) {} explicit cauchy_distribution(RealType a, RealType b = 1.0); explicit cauchy_distribution(const param_type& parm); void reset(); / equality operators friend bool operator=(const cauchy_distribution& x, const cauchy_distribution& y); / generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); / property functions RealType a() const; RealType b() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; / inserters and extractors template<class charT, class traits> friend basic_ostream<charT, traits>& operator<(basic_ostream<charT, traits>& os, const cauchy_distribution& x); template<class charT, class traits> friend basic_istream<charT, traits>& operator>(basic_istream<charT, traits>& is, cauchy_distribution& x); }; }
🔗
explicit cauchy_distribution(RealType a, RealType b = 1.0);
2
#
Remarks: a and b correspond to the respective parameters of the distribution.
🔗
RealType a() const;
4
#
Returns: The value of the a parameter with which the object was constructed.
🔗
RealType b() const;
5
#
Returns: The value of the b parameter with which the object was constructed.

29.5.9.5.5 Class template fisher_f_distribution [rand.dist.norm.f]

1
#
A fisher_f_distribution random number distribution produces random numbers x  ≥ 0 distributed according to the probability density function in Formula 29.17.
🔗
namespace std { template<class RealType = double> class fisher_f_distribution { public: / types using result_type = RealType; using param_type = unspecified; / constructor and reset functions fisher_f_distribution() : fisher_f_distribution(1.0) {} explicit fisher_f_distribution(RealType m, RealType n = 1.0); explicit fisher_f_distribution(const param_type& parm); void reset(); / equality operators friend bool operator=(const fisher_f_distribution& x, const fisher_f_distribution& y); / generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); / property functions RealType m() const; RealType n() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; / inserters and extractors template<class charT, class traits> friend basic_ostream<charT, traits>& operator<(basic_ostream<charT, traits>& os, const fisher_f_distribution& x); template<class charT, class traits> friend basic_istream<charT, traits>& operator>(basic_istream<charT, traits>& is, fisher_f_distribution& x); }; }
🔗
explicit fisher_f_distribution(RealType m, RealType n = 1);
2
#
Remarks: m and n correspond to the respective parameters of the distribution.
🔗
RealType m() const;
4
#
Returns: The value of the m parameter with which the object was constructed.
🔗
RealType n() const;
5
#
Returns: The value of the n parameter with which the object was constructed.

29.5.9.5.6 Class template student_t_distribution [rand.dist.norm.t]

1
#
A student_t_distribution random number distribution produces random numbers x distributed according to the probability density function in Formula 29.18.
🔗
namespace std { template<class RealType = double> class student_t_distribution { public: / types using result_type = RealType; using param_type = unspecified; / constructor and reset functions student_t_distribution() : student_t_distribution(1.0) {} explicit student_t_distribution(RealType n); explicit student_t_distribution(const param_type& parm); void reset(); / equality operators friend bool operator=(const student_t_distribution& x, const student_t_distribution& y); / generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); / property functions RealType n() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; / inserters and extractors template<class charT, class traits> friend basic_ostream<charT, traits>& operator<(basic_ostream<charT, traits>& os, const student_t_distribution& x); template<class charT, class traits> friend basic_istream<charT, traits>& operator>(basic_istream<charT, traits>& is, student_t_distribution& x); }; }
🔗
explicit student_t_distribution(RealType n);
2
#
Remarks: n corresponds to the parameter of the distribution.
🔗
RealType n() const;
4
#
Returns: The value of the n parameter with which the object was constructed.

29.5.9.6 Sampling distributions [rand.dist.samp]

29.5.9.6.1 Class template discrete_distribution [rand.dist.samp.discrete]

1
#
A discrete_distribution random number distribution produces random integers i,
2
#
Unless specified otherwise, the distribution parameters are calculated as:
Moreover, the following relation shall hold:
🔗
namespace std { template<class IntType = int> class discrete_distribution { public: / types using result_type = IntType; using param_type = unspecified; / constructor and reset functions discrete_distribution(); template<class InputIterator> discrete_distribution(InputIterator firstW, InputIterator lastW); discrete_distribution(initializer_list<double> wl); template<class UnaryOperation> discrete_distribution(size_t nw, double xmin, double xmax, UnaryOperation fw); explicit discrete_distribution(const param_type& parm); void reset(); / equality operators friend bool operator=(const discrete_distribution& x, const discrete_distribution& y); / generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); / property functions vector<double> probabilities() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; / inserters and extractors template<class charT, class traits> friend basic_ostream<charT, traits>& operator<(basic_ostream<charT, traits>& os, const discrete_distribution& x); template<class charT, class traits> friend basic_istream<charT, traits>& operator>(basic_istream<charT, traits>& is, discrete_distribution& x); }; }
🔗
discrete_distribution();
3
#
Effects: Constructs a discrete_distribution object with
[Note 1: 
Such an object will always deliver the value 0.
— end note]
🔗
template<class InputIterator> discrete_distribution(InputIterator firstW, InputIterator lastW);
4
#
Mandates: is_convertible_v<iterator_traits<InputIterator>​::​value_type, double> is true.
5
#
Preconditions: InputIterator meets the Cpp17InputIterator requirements ([input.iterators]).
If firstW == lastW, let
Otherwise, [firstW, lastW) forms a sequence w of length
6
#
Effects: Constructs a discrete_distribution object with probabilities given by the Formula 29.19.
🔗
discrete_distribution(initializer_list<double> wl);
7
#
Effects: Same as discrete_distribution(wl.begin(), wl.end().
🔗
template<class UnaryOperation> discrete_distribution(size_t nw, double xmin, double xmax, UnaryOperation fw);
8
#
Preconditions: If
The relation
10
#
Effects: Constructs a discrete_distribution object with probabilities given by the formula above, using the following values: If
Otherwise, let
11
#
Complexity: The number of invocations of fw does not exceed n.
🔗
vector<double> probabilities() const;
12
#
Returns: A vector<double> whose size member returns n and whose operator[] member returns

29.5.9.6.2 Class template piecewise_constant_distribution [rand.dist.samp.pconst]

1
#
A piecewise_constant_distribution random number distribution produces random numbers x,
2
#
The
Unless specified otherwise, the remaining n distribution parameters are calculated as:
Moreover, the following relation shall hold:
🔗
namespace std { template<class RealType = double> class piecewise_constant_distribution { public: / types using result_type = RealType; using param_type = unspecified; / constructor and reset functions piecewise_constant_distribution(); template<class InputIteratorB, class InputIteratorW> piecewise_constant_distribution(InputIteratorB firstB, InputIteratorB lastB, InputIteratorW firstW); template<class UnaryOperation> piecewise_constant_distribution(initializer_list<RealType> bl, UnaryOperation fw); template<class UnaryOperation> piecewise_constant_distribution(size_t nw, RealType xmin, RealType xmax, UnaryOperation fw); explicit piecewise_constant_distribution(const param_type& parm); void reset(); / equality operators friend bool operator=(const piecewise_constant_distribution& x, const piecewise_constant_distribution& y); / generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); / property functions vector<result_type> intervals() const; vector<result_type> densities() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; / inserters and extractors template<class charT, class traits> friend basic_ostream<charT, traits>& operator<(basic_ostream<charT, traits>& os, const piecewise_constant_distribution& x); template<class charT, class traits> friend basic_istream<charT, traits>& operator>(basic_istream<charT, traits>& is, piecewise_constant_distribution& x); }; }
🔗
piecewise_constant_distribution();
3
#
Effects: Constructs a piecewise_constant_distribution object with
🔗
template<class InputIteratorB, class InputIteratorW> piecewise_constant_distribution(InputIteratorB firstB, InputIteratorB lastB, InputIteratorW firstW);
4
#
Mandates: Both of
  • (4.1)
    is_convertible_v<iterator_traits<InputIteratorB>​::​value_type, double>
  • (4.2)
    is_convertible_v<iterator_traits<InputIteratorW>​::​value_type, double>
are true.
5
#
Preconditions: InputIteratorB and InputIteratorW each meet the Cpp17InputIterator requirements ([input.iterators]).
If firstB == lastB or ++firstB == lastB, let
Otherwise, [firstB, lastB) forms a sequence b of length
6
#
Effects: Constructs a piecewise_constant_distribution object with parameters as specified above.
🔗
template<class UnaryOperation> piecewise_constant_distribution(initializer_list<RealType> bl, UnaryOperation fw);
7
#
Effects: Constructs a piecewise_constant_distribution object with parameters taken or calculated from the following values: If
Otherwise, let [bl.begin(), bl.end()) form a sequence
9
#
Complexity: The number of invocations of fw does not exceed n.
🔗
template<class UnaryOperation> piecewise_constant_distribution(size_t nw, RealType xmin, RealType xmax, UnaryOperation fw);
10
#
Preconditions: If
The relation
12
#
Effects: Constructs a piecewise_constant_distribution object with parameters taken or calculated from the following values: Let
13
#
Complexity: The number of invocations of fw does not exceed n.
🔗
vector<result_type> intervals() const;
14
#
Returns: A vector<result_type> whose size member returns
🔗
vector<result_type> densities() const;
15
#
Returns: A vector<result_type> whose size member returns n and whose operator[] member returns

29.5.9.6.3 Class template piecewise_linear_distribution [rand.dist.samp.plinear]

1
#
A piecewise_linear_distribution random number distribution produces random numbers x,
2
#
The
Unless specified otherwise, the remaining
Moreover, the following relation shall hold:
🔗
namespace std { template<class RealType = double> class piecewise_linear_distribution { public: / types using result_type = RealType; using param_type = unspecified; / constructor and reset functions piecewise_linear_distribution(); template<class InputIteratorB, class InputIteratorW> piecewise_linear_distribution(InputIteratorB firstB, InputIteratorB lastB, InputIteratorW firstW); template<class UnaryOperation> piecewise_linear_distribution(initializer_list<RealType> bl, UnaryOperation fw); template<class UnaryOperation> piecewise_linear_distribution(size_t nw, RealType xmin, RealType xmax, UnaryOperation fw); explicit piecewise_linear_distribution(const param_type& parm); void reset(); / equality operators friend bool operator=(const piecewise_linear_distribution& x, const piecewise_linear_distribution& y); / generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); / property functions vector<result_type> intervals() const; vector<result_type> densities() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; / inserters and extractors template<class charT, class traits> friend basic_ostream<charT, traits>& operator<(basic_ostream<charT, traits>& os, const piecewise_linear_distribution& x); template<class charT, class traits> friend basic_istream<charT, traits>& operator>(basic_istream<charT, traits>& is, piecewise_linear_distribution& x); }; }
🔗
piecewise_linear_distribution();
3
#
Effects: Constructs a piecewise_linear_distribution object with
🔗
template<class InputIteratorB, class InputIteratorW> piecewise_linear_distribution(InputIteratorB firstB, InputIteratorB lastB, InputIteratorW firstW);
4
#
Mandates: Both of
  • (4.1)
    is_convertible_v<iterator_traits<InputIteratorB>​::​value_type, double>
  • (4.2)
    is_convertible_v<iterator_traits<InputIteratorW>​::​value_type, double>
are true.
5
#
Preconditions: InputIteratorB and InputIteratorW each meet the Cpp17InputIterator requirements ([input.iterators]).
If firstB == lastB or ++firstB == lastB, let
Otherwise, [firstB, lastB) forms a sequence b of length
6
#
Effects: Constructs a piecewise_linear_distribution object with parameters as specified above.
🔗
template<class UnaryOperation> piecewise_linear_distribution(initializer_list<RealType> bl, UnaryOperation fw);
7
#
Effects: Constructs a piecewise_linear_distribution object with parameters taken or calculated from the following values: If
Otherwise, let [bl.begin(), bl.end()) form a sequence
9
#
Complexity: The number of invocations of fw does not exceed
🔗
template<class UnaryOperation> piecewise_linear_distribution(size_t nw, RealType xmin, RealType xmax, UnaryOperation fw);
10
#
Preconditions: If
The relation
12
#
Effects: Constructs a piecewise_linear_distribution object with parameters taken or calculated from the following values: Let
13
#
Complexity: The number of invocations of fw does not exceed
🔗
vector<result_type> intervals() const;
14
#
Returns: A vector<result_type> whose size member returns
🔗
vector<result_type> densities() const;
15
#
Returns: A vector<result_type> whose size member returns n and whose operator[] member returns

29.5.10 Low-quality random number generation [c.math.rand]

1
#
[Note 1: 
The header <cstdlib> declares the functions described in this subclause.
— end note]
🔗
int rand(); void srand(unsigned int seed);
2
#
Effects: The rand and srand functions have the semantics specified in the C standard library.
3
#
Remarks: The implementation may specify that particular library functions may call rand.
It is implementation-defined whether the rand function may introduce data races ([res.on.data.races]).
[Note 2: 
The other random number generation facilities in this document ([rand]) are often preferable to rand, because rand's underlying algorithm is unspecified.
Use of rand therefore continues to be non-portable, with unpredictable and oft-questionable quality and performance.
— end note]
See also: ISO/IEC 9899:2024, 7.24.3

29.6 Numeric arrays [numarray]

29.6.1 Header <valarray> synopsis [valarray.syn]

🔗
#include <initializer_list> / see [initializer.list.syn] namespace std { template<class T> class valarray; / An array of type T class slice; / a BLAS-like slice out of an array template<class T> class slice_array; class gslice; / a generalized slice out of an array template<class T> class gslice_array; template<class T> class mask_array; / a masked array template<class T> class indirect_array; / an indirected array template<class T> void swap(valarray<T>&, valarray<T>&) noexcept; template<class T> valarray<T> operator* (const valarray<T>&, const valarray<T>&); template<class T> valarray<T> operator* (const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<T> operator* (const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<T> operator/ (const valarray<T>&, const valarray<T>&); template<class T> valarray<T> operator/ (const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<T> operator/ (const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<T> operator% (const valarray<T>&, const valarray<T>&); template<class T> valarray<T> operator% (const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<T> operator% (const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<T> operator+ (const valarray<T>&, const valarray<T>&); template<class T> valarray<T> operator+ (const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<T> operator+ (const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<T> operator- (const valarray<T>&, const valarray<T>&); template<class T> valarray<T> operator- (const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<T> operator- (const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<T> operator^ (const valarray<T>&, const valarray<T>&); template<class T> valarray<T> operator^ (const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<T> operator^ (const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<T> operator& (const valarray<T>&, const valarray<T>&); template<class T> valarray<T> operator& (const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<T> operator& (const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<T> operator| (const valarray<T>&, const valarray<T>&); template<class T> valarray<T> operator| (const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<T> operator| (const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<T> operator<(const valarray<T>&, const valarray<T>&); template<class T> valarray<T> operator<(const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<T> operator<(const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<T> operator>(const valarray<T>&, const valarray<T>&); template<class T> valarray<T> operator>(const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<T> operator>(const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<bool> operator&(const valarray<T>&, const valarray<T>&); template<class T> valarray<bool> operator&(const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<bool> operator&(const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<bool> operator|(const valarray<T>&, const valarray<T>&); template<class T> valarray<bool> operator|(const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<bool> operator|(const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<bool> operator=(const valarray<T>&, const valarray<T>&); template<class T> valarray<bool> operator=(const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<bool> operator=(const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<bool> operator!=(const valarray<T>&, const valarray<T>&); template<class T> valarray<bool> operator!=(const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<bool> operator!=(const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<bool> operator< (const valarray<T>&, const valarray<T>&); template<class T> valarray<bool> operator< (const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<bool> operator< (const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<bool> operator> (const valarray<T>&, const valarray<T>&); template<class T> valarray<bool> operator> (const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<bool> operator> (const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<bool> operator<=(const valarray<T>&, const valarray<T>&); template<class T> valarray<bool> operator<=(const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<bool> operator<=(const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<bool> operator>=(const valarray<T>&, const valarray<T>&); template<class T> valarray<bool> operator>=(const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<bool> operator>=(const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<T> abs (const valarray<T>&); template<class T> valarray<T> acos (const valarray<T>&); template<class T> valarray<T> asin (const valarray<T>&); template<class T> valarray<T> atan (const valarray<T>&); template<class T> valarray<T> atan2(const valarray<T>&, const valarray<T>&); template<class T> valarray<T> atan2(const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<T> atan2(const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<T> cos (const valarray<T>&); template<class T> valarray<T> cosh (const valarray<T>&); template<class T> valarray<T> exp (const valarray<T>&); template<class T> valarray<T> log (const valarray<T>&); template<class T> valarray<T> log10(const valarray<T>&); template<class T> valarray<T> pow(const valarray<T>&, const valarray<T>&); template<class T> valarray<T> pow(const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<T> pow(const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<T> sin (const valarray<T>&); template<class T> valarray<T> sinh (const valarray<T>&); template<class T> valarray<T> sqrt (const valarray<T>&); template<class T> valarray<T> tan (const valarray<T>&); template<class T> valarray<T> tanh (const valarray<T>&); }
1
#
The header <valarray> defines five class templates (valarray, slice_array, gslice_array, mask_array, and indirect_array), two classes (slice and gslice), and a series of related function templates for representing and manipulating arrays of values.
2
#
The valarray array classes are defined to be free of certain forms of aliasing, thus allowing operations on these classes to be optimized.
3
#
Any function returning a valarray<T> is permitted to return an object of another type, provided all the const member functions of valarray<T> other than begin and end are also applicable to this type.
This return type shall not add more than two levels of template nesting over the most deeply nested argument type.239
4
#
Implementations introducing such replacement types shall provide additional functions and operators as follows:
  • (4.1)
    for every function taking a const valarray<T>&, identical functions taking the replacement types shall be added;
  • (4.2)
    for every function taking two const valarray<T>& arguments, identical functions taking every combination of const valarray<T>& and replacement types shall be added.
5
#
In particular, an implementation shall allow a valarray<T> to be constructed from such replacement types and shall allow assignments and compound assignments of such types to valarray<T>, slice_array<T>, gslice_array<T>, mask_array<T> and indirect_array<T> objects.
6
#
These library functions are permitted to throw a bad_alloc exception if there are not sufficient resources available to carry out the operation.
Note that the exception is not mandated.
239)239)
[implimits] recommends a minimum number of recursively nested template instantiations.
This requirement thus indirectly suggests a minimum allowable complexity for valarray expressions.

29.6.2 Class template valarray [template.valarray]

🔗
namespace std { template<class T> class valarray { public: using value_type = T; using iterator = unspecified; using const_iterator = unspecified; / [valarray.cons], construct/destroy valarray(); explicit valarray(size_t); valarray(const T&, size_t); valarray(const T*, size_t); valarray(const valarray&); valarray(valarray&&) noexcept; valarray(const slice_array<T>&); valarray(const gslice_array<T>&); valarray(const mask_array<T>&); valarray(const indirect_array<T>&); valarray(initializer_list<T>); ~valarray(); / [valarray.assign], assignment valarray& operator=(const valarray&); valarray& operator=(valarray&&) noexcept; valarray& operator=(initializer_list<T>); valarray& operator=(const T&); valarray& operator=(const slice_array<T>&); valarray& operator=(const gslice_array<T>&); valarray& operator=(const mask_array<T>&); valarray& operator=(const indirect_array<T>&); / [valarray.access], element access const T& operator[](size_t) const; T& operator[](size_t); / [valarray.sub], subset operations valarray operator[](slice) const; slice_array<T> operator[](slice); valarray operator[](const gslice&) const; gslice_array<T> operator[](const gslice&); valarray operator[](const valarray<bool>&) const; mask_array<T> operator[](const valarray<bool>&); valarray operator[](const valarray<size_t>&) const; indirect_array<T> operator[](const valarray<size_t>&); / [valarray.unary], unary operators valarray operator+() const; valarray operator-() const; valarray operator~() const; valarray<bool> operator!() const; / [valarray.cassign], compound assignment valarray& operator*= (const T&); valarray& operator/= (const T&); valarray& operator%= (const T&); valarray& operator+= (const T&); valarray& operator-= (const T&); valarray& operator^= (const T&); valarray& operator&= (const T&); valarray& operator|= (const T&); valarray& operator<=(const T&); valarray& operator>=(const T&); valarray& operator*= (const valarray&); valarray& operator/= (const valarray&); valarray& operator%= (const valarray&); valarray& operator+= (const valarray&); valarray& operator-= (const valarray&); valarray& operator^= (const valarray&); valarray& operator|= (const valarray&); valarray& operator&= (const valarray&); valarray& operator<=(const valarray&); valarray& operator>=(const valarray&); / [valarray.range], range access iterator begin(); iterator end(); const_iterator begin() const; const_iterator end() const; / [valarray.members], member functions void swap(valarray&) noexcept; size_t size() const; T sum() const; T min() const; T max() const; valarray shift (int) const; valarray cshift(int) const; valarray apply(T func(T)) const; valarray apply(T func(const T&) const; void resize(size_t sz, T c = T(); }; template<class T, size_t cnt> valarray(const T(&)[cnt], size_t) -> valarray<T>; }
1
#
The class template valarray<T> is a one-dimensional smart array, with elements numbered sequentially from zero.
It is a representation of the mathematical concept of an ordered set of values.
For convenience, an object of type valarray<T> is referred to as an “array” throughout the remainder of [numarray].
The illusion of higher dimensionality may be produced by the familiar idiom of computed indices, together with the powerful subsetting capabilities provided by the generalized subscript operators.240
240)240)
The intent is to specify an array template that has the minimum functionality necessary to address aliasing ambiguities and the proliferation of temporary objects.
Thus, the valarray template is neither a matrix class nor a field class.
However, it is a very useful building block for designing such classes.
🔗
valarray();
1
#
Effects: Constructs a valarray that has zero length.241
🔗
explicit valarray(size_t n);
2
#
Effects: Constructs a valarray that has length n.
Each element of the array is value-initialized.
🔗
valarray(const T& v, size_t n);
3
#
Effects: Constructs a valarray that has length n.
Each element of the array is initialized with v.
🔗
valarray(const T* p, size_t n);
4
#
Effects: Constructs a valarray that has length n.
The values of the elements of the array are initialized with the first n values pointed to by the first argument.242
🔗
valarray(const valarray& v);
6
#
Effects: Constructs a valarray that has the same length as v.
The elements are initialized with the values of the corresponding elements of v.243
🔗
valarray(valarray&& v) noexcept;
7
#
Effects: Constructs a valarray that has the same length as v.
The elements are initialized with the values of the corresponding elements of v.
8
#
Complexity: Constant.
🔗
valarray(initializer_list<T> il);
9
#
Effects: Equivalent to valarray(il.data(), il.size().
🔗
valarray(const slice_array<T>&); valarray(const gslice_array<T>&); valarray(const mask_array<T>&); valarray(const indirect_array<T>&);
10
#
These conversion constructors convert one of the four reference templates to a valarray.
🔗
~valarray();
11
#
Effects: The destructor is applied to every element of *this; an implementation may return all allocated memory.
241)241)
This default constructor is essential, since arrays of valarray can be useful.
After initialization, the length of an empty array can be increased with the resize member function.
242)242)
This constructor is the preferred method for converting a C array to a valarray object.
243)243)
This copy constructor creates a distinct array rather than an alias.
Implementations in which arrays share storage are permitted, but they would need to implement a copy-on-reference mechanism to ensure that arrays are conceptually distinct.
🔗
valarray& operator=(const valarray& v);
1
#
Effects: Each element of the *this array is assigned the value of the corresponding element of v.
If the length of v is not equal to the length of *this, resizes *this to make the two arrays the same length, as if by calling resize(v.size(), before performing the assignment.
2
#
Returns: *this.
🔗
valarray& operator=(valarray&& v) noexcept;
4
#
Complexity: Linear.
🔗
valarray& operator=(initializer_list<T> il);
7
#
Effects: Equivalent to: return *this = valarray(il);
🔗
valarray& operator=(const T& v);
8
#
Returns: *this.
🔗
valarray& operator=(const slice_array<T>&); valarray& operator=(const gslice_array<T>&); valarray& operator=(const mask_array<T>&); valarray& operator=(const indirect_array<T>&);
10
#
Preconditions: The length of the array to which the argument refers equals size().
The value of an element in the left-hand side of a valarray assignment operator does not depend on the value of another element in that left-hand side.
11
#
These operators allow the results of a generalized subscripting operation to be assigned directly to a valarray.
🔗
const T& operator[](size_t n) const; T& operator[](size_t n);
1
#
Returns: A reference to the corresponding element of the array.
[Note 1: 
The expression (a[i] = q, a[i]) == q evaluates to true for any non-constant valarray<T> a, any T q, and for any size_t i such that the value of i is less than the length of a.
— end note]
3
#
Remarks: The expression addressof(a[i + j]) == addressof(a[i]) + j evaluates to true for all size_t i and size_t j such that i + j < a.size().
4
#
The expression addressof(a[i]) != addressof(b[j]) evaluates to true for any two arrays a and b and for any size_t i and size_t j such that i < a.size() and j < b.size().
[Note 2: 
This property indicates an absence of aliasing and can be used to advantage by optimizing compilers.
Compilers can take advantage of inlining, constant propagation, loop fusion, tracking of pointers obtained from operator new, and other techniques to generate efficient valarrays.
— end note]
5
#
The reference returned by the subscript operator for an array shall be valid until the member function resize(size_t, T) is called for that array or until the lifetime of that array ends, whichever happens first.

29.6.2.5 Subset operations [valarray.sub]

1
#
The member operator[] is overloaded to provide several ways to select sequences of elements from among those controlled by *this.
Each of these operations returns a subset of the array.
The const-qualified versions return this subset as a new valarray object.
The non-const versions return a class template object which has reference semantics to the original array, working in conjunction with various overloads of operator= and other assigning operators to allow selective replacement (slicing) of the controlled sequence.
In each case the selected element(s) shall exist.
🔗
valarray operator[](slice slicearr) const;
2
#
Returns: A valarray containing those elements of the controlled sequence designated by slicearr.
[Example 1: const valarray<char> v0("abcdefghijklmnop", 16); / v0[slice(2, 5, 3)] returns valarray<char>("cfilo", 5) — end example]
🔗
slice_array<T> operator[](slice slicearr);
3
#
Returns: An object that holds references to elements of the controlled sequence selected by slicearr.
[Example 2: valarray<char> v0("abcdefghijklmnop", 16); valarray<char> v1("ABCDE", 5); v0[slice(2, 5, 3)] = v1; / v0 == valarray<char>("abAdeBghCjkDmnEp", 16); — end example]
🔗
valarray operator[](const gslice& gslicearr) const;
4
#
Returns: A valarray containing those elements of the controlled sequence designated by gslicearr.
[Example 3: const valarray<char> v0("abcdefghijklmnop", 16); const size_t lv[] = { 2, 3 }; const size_t dv[] = { 7, 2 }; const valarray<size_t> len(lv, 2), str(dv, 2); / v0[gslice(3, len, str)] returns / valarray<char>("dfhkmo", 6) — end example]
🔗
gslice_array<T> operator[](const gslice& gslicearr);
5
#
Returns: An object that holds references to elements of the controlled sequence selected by gslicearr.
[Example 4: valarray<char> v0("abcdefghijklmnop", 16); valarray<char> v1("ABCDEF", 6); const size_t lv[] = { 2, 3 }; const size_t dv[] = { 7, 2 }; const valarray<size_t> len(lv, 2), str(dv, 2); v0[gslice(3, len, str)] = v1; / v0 == valarray<char>("abcAeBgCijDlEnFp", 16) — end example]
🔗
valarray operator[](const valarray<bool>& boolarr) const;
6
#
Returns: A valarray containing those elements of the controlled sequence designated by boolarr.
[Example 5: const valarray<char> v0("abcdefghijklmnop", 16); const bool vb[] = { false, false, true, false, true }; / v0[valarray<bool>(vb, 6)] returns / valarray<char>("cdf", 3) — end example]
🔗
mask_array<T> operator[](const valarray<bool>& boolarr);
7
#
Returns: An object that holds references to elements of the controlled sequence selected by boolarr.
[Example 6: valarray<char> v0("abcdefghijklmnop", 16); valarray<char> v1("ABC", 3); const bool vb[] = { false, false, true, false, true }; v0[valarray<bool>(vb, 6)] = v1; / v0 == valarray<char>("abABeCghijklmnop", 16) — end example]
🔗
valarray operator[](const valarray<size_t>& indarr) const;
8
#
Returns: A valarray containing those elements of the controlled sequence designated by indarr.
[Example 7: const valarray<char> v0("abcdefghijklmnop", 16); const size_t vi[] = { 7, 5, 2, 3, 8 }; / v0[valarray<size_t>(vi, 5)] returns / valarray<char>("hfcdi", 5) — end example]
🔗
indirect_array<T> operator[](const valarray<size_t>& indarr);
9
#
Returns: An object that holds references to elements of the controlled sequence selected by indarr.
[Example 8: valarray<char> v0("abcdefghijklmnop", 16); valarray<char> v1("ABCDE", 5); const size_t vi[] = { 7, 5, 2, 3, 8 }; v0[valarray<size_t>(vi, 5)] = v1; / v0 == valarray<char>("abCDeBgAEjklmnop", 16) — end example]

29.6.2.6 Unary operators [valarray.unary]

🔗
valarray operator+() const; valarray operator-() const; valarray operator~() const; valarray<bool> operator!() const;
1
#
Mandates: The indicated operator can be applied to operands of type T and returns a value of type T (bool for operator!) or which may be unambiguously implicitly converted to type T (bool for operator!).
2
#
Returns: A valarray whose length is size().
Each element of the returned array is initialized with the result of applying the indicated operator to the corresponding element of the array.

29.6.2.7 Compound assignment [valarray.cassign]

🔗
valarray& operator*= (const valarray& v); valarray& operator/= (const valarray& v); valarray& operator%= (const valarray& v); valarray& operator+= (const valarray& v); valarray& operator-= (const valarray& v); valarray& operator^= (const valarray& v); valarray& operator&= (const valarray& v); valarray& operator|= (const valarray& v); valarray& operator<=(const valarray& v); valarray& operator>=(const valarray& v);
1
#
Preconditions: size() == v.size() is true.
The value of an element in the left-hand side of a valarray compound assignment operator does not depend on the value of another element in that left hand side.
3
#
Effects: Each of these operators performs the indicated operation on each of the elements of *this and the corresponding element of v.
4
#
Remarks: The appearance of an array on the left-hand side of a compound assignment does not invalidate references or pointers.
🔗
valarray& operator*= (const T& v); valarray& operator/= (const T& v); valarray& operator%= (const T& v); valarray& operator+= (const T& v); valarray& operator-= (const T& v); valarray& operator^= (const T& v); valarray& operator&= (const T& v); valarray& operator|= (const T& v); valarray& operator<=(const T& v); valarray& operator>=(const T& v);
6
#
Effects: Each of these operators applies the indicated operation to each element of *this and v.
8
#
Remarks: The appearance of an array on the left-hand side of a compound assignment does not invalidate references or pointers to the elements of the array.

29.6.2.8 Member functions [valarray.members]

🔗
void swap(valarray& v) noexcept;
1
#
Effects: *this obtains the value of v.
v obtains the value of *this.
2
#
Complexity: Constant.
🔗
size_t size() const;
3
#
Complexity: Constant time.
🔗
T sum() const;
5
#
Returns: The sum of all the elements of the array.
If the array has length 1, returns the value of element 0.
Otherwise, the returned value is calculated by applying operator+= to a copy of an element of the array and all other elements of the array in an unspecified order.
🔗
T min() const;
8
#
Returns: The minimum value contained in *this.
For an array of length 1, the value of element 0 is returned.
For all other array lengths, the determination is made using operator<.
🔗
T max() const;
10
#
Returns: The maximum value contained in *this.
For an array of length 1, the value of element 0 is returned.
For all other array lengths, the determination is made using operator<.
🔗
valarray shift(int n) const;
12
#
Returns: A valarray of length size(), each of whose elements I is (*this)[I + n] if I + n is non-negative and less than size(), otherwise T().
[Note 1: 
If element zero is taken as the leftmost element, a positive value of n shifts the elements left n places, with zero fill.
— end note]
13
#
[Example 1: 
If the argument has the value
— end example]
🔗
valarray cshift(int n) const;
14
#
Returns: A valarray of length size() that is a circular shift of *this.
If element zero is taken as the leftmost element, a non-negative value of n shifts the elements circularly left n places and a negative value of n shifts the elements circularly right
🔗
valarray apply(T func(T)) const; valarray apply(T func(const T&) const;
15
#
Returns: A valarray whose length is size().
Each element of the returned array is assigned the value returned by applying the argument function to the corresponding element of *this.
🔗
void resize(size_t sz, T c = T();
16
#
Effects: Changes the length of the *this array to sz and then assigns to each element the value of the second argument.
Resizing invalidates all pointers and references to elements in the array.

29.6.3 valarray non-member operations [valarray.nonmembers]

29.6.3.1 Binary operators [valarray.binary]

🔗
template<class T> valarray<T> operator* (const valarray<T>&, const valarray<T>&); template<class T> valarray<T> operator/ (const valarray<T>&, const valarray<T>&); template<class T> valarray<T> operator% (const valarray<T>&, const valarray<T>&); template<class T> valarray<T> operator+ (const valarray<T>&, const valarray<T>&); template<class T> valarray<T> operator- (const valarray<T>&, const valarray<T>&); template<class T> valarray<T> operator^ (const valarray<T>&, const valarray<T>&); template<class T> valarray<T> operator& (const valarray<T>&, const valarray<T>&); template<class T> valarray<T> operator| (const valarray<T>&, const valarray<T>&); template<class T> valarray<T> operator<(const valarray<T>&, const valarray<T>&); template<class T> valarray<T> operator>(const valarray<T>&, const valarray<T>&);
1
#
Mandates: The indicated operator can be applied to operands of type T and returns a value of type T or which can be unambiguously implicitly converted to T.
2
#
Returns: A valarray whose length is equal to the lengths of the argument arrays.
Each element of the returned array is initialized with the result of applying the indicated operator to the corresponding elements of the argument arrays.
🔗
template<class T> valarray<T> operator* (const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<T> operator* (const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<T> operator/ (const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<T> operator/ (const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<T> operator% (const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<T> operator% (const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<T> operator+ (const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<T> operator+ (const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<T> operator- (const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<T> operator- (const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<T> operator^ (const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<T> operator^ (const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<T> operator& (const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<T> operator& (const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<T> operator| (const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<T> operator| (const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<T> operator<(const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<T> operator<(const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<T> operator>(const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<T> operator>(const typename valarray<T>::value_type&, const valarray<T>&);
4
#
Mandates: The indicated operator can be applied to operands of type T and returns a value of type T or which can be unambiguously implicitly converted to T.
5
#
Returns: A valarray whose length is equal to the length of the array argument.
Each element of the returned array is initialized with the result of applying the indicated operator to the corresponding element of the array argument and the non-array argument.
🔗
template<class T> valarray<bool> operator=(const valarray<T>&, const valarray<T>&); template<class T> valarray<bool> operator!=(const valarray<T>&, const valarray<T>&); template<class T> valarray<bool> operator< (const valarray<T>&, const valarray<T>&); template<class T> valarray<bool> operator> (const valarray<T>&, const valarray<T>&); template<class T> valarray<bool> operator<=(const valarray<T>&, const valarray<T>&); template<class T> valarray<bool> operator>=(const valarray<T>&, const valarray<T>&); template<class T> valarray<bool> operator&(const valarray<T>&, const valarray<T>&); template<class T> valarray<bool> operator|(const valarray<T>&, const valarray<T>&);
1
#
Mandates: The indicated operator can be applied to operands of type T and returns a value of type bool or which can be unambiguously implicitly converted to bool.
2
#
Returns: A valarray<bool> whose length is equal to the length of the array arguments.
Each element of the returned array is initialized with the result of applying the indicated operator to the corresponding elements of the argument arrays.
🔗
template<class T> valarray<bool> operator=(const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<bool> operator=(const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<bool> operator!=(const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<bool> operator!=(const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<bool> operator< (const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<bool> operator< (const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<bool> operator> (const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<bool> operator> (const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<bool> operator<=(const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<bool> operator<=(const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<bool> operator>=(const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<bool> operator>=(const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<bool> operator&(const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<bool> operator&(const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<bool> operator|(const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<bool> operator|(const typename valarray<T>::value_type&, const valarray<T>&);
4
#
Mandates: The indicated operator can be applied to operands of type T and returns a value of type bool or which can be unambiguously implicitly converted to bool.
5
#
Returns: A valarray<bool> whose length is equal to the length of the array argument.
Each element of the returned array is initialized with the result of applying the indicated operator to the corresponding element of the array and the non-array argument.
🔗
template<class T> valarray<T> abs (const valarray<T>&); template<class T> valarray<T> acos (const valarray<T>&); template<class T> valarray<T> asin (const valarray<T>&); template<class T> valarray<T> atan (const valarray<T>&); template<class T> valarray<T> atan2(const valarray<T>&, const valarray<T>&); template<class T> valarray<T> atan2(const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<T> atan2(const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<T> cos (const valarray<T>&); template<class T> valarray<T> cosh (const valarray<T>&); template<class T> valarray<T> exp (const valarray<T>&); template<class T> valarray<T> log (const valarray<T>&); template<class T> valarray<T> log10(const valarray<T>&); template<class T> valarray<T> pow (const valarray<T>&, const valarray<T>&); template<class T> valarray<T> pow (const valarray<T>&, const typename valarray<T>::value_type&); template<class T> valarray<T> pow (const typename valarray<T>::value_type&, const valarray<T>&); template<class T> valarray<T> sin (const valarray<T>&); template<class T> valarray<T> sinh (const valarray<T>&); template<class T> valarray<T> sqrt (const valarray<T>&); template<class T> valarray<T> tan (const valarray<T>&); template<class T> valarray<T> tanh (const valarray<T>&);
1
#
Mandates: A unique function with the indicated name can be applied (unqualified) to an operand of type T.
This function returns a value of type T or which can be unambiguously implicitly converted to type T.

29.6.3.4 Specialized algorithms [valarray.special]

🔗
template<class T> void swap(valarray<T>& x, valarray<T>& y) noexcept;
1
#
Effects: Equivalent to x.swap(y).

29.6.4 Class slice [class.slice]

🔗
namespace std { class slice { public: slice(); slice(size_t, size_t, size_t); slice(const slice&); size_t start() const; size_t size() const; size_t stride() const; friend bool operator=(const slice& x, const slice& y); }; }
1
#
The slice class represents a BLAS-like slice from an array.
Such a slice is specified by a starting index, a length, and a stride.244
244)244)
BLAS stands for Basic Linear Algebra Subprograms.
C++ programs can instantiate this class.
See, for example, Dongarra, Du Croz, Duff, and Hammerling: A set of Level 3 Basic Linear Algebra Subprograms; Technical Report MCS-P1-0888, Argonne National Laboratory (USA), Mathematics and Computer Science Division, August, 1988.

29.6.4.2 Constructors [cons.slice]

🔗
slice(); slice(size_t start, size_t length, size_t stride);
1
#
The default constructor is equivalent to slice(0, 0).
A default constructor is provided only to permit the declaration of arrays of slices.
The constructor with arguments for a slice takes a start, length, and stride parameter.
2
#
[Example 1: 
slice(3, 8, 2) constructs a slice which selects elements
— end example]

29.6.4.3 Access functions [slice.access]

🔗
size_t start() const; size_t size() const; size_t stride() const;
1
#
Returns: The start, length, or stride specified by a slice object.
2
#
Complexity: Constant time.
🔗
friend bool operator=(const slice& x, const slice& y);
1
#
Effects: Equivalent to: return x.start() == y.start() && x.size() == y.size() && x.stride() == y.stride();

29.6.5 Class template slice_array [template.slice.array]

🔗
namespace std { template<class T> class slice_array { public: using value_type = T; void operator= (const valarray<T>&) const; void operator*= (const valarray<T>&) const; void operator/= (const valarray<T>&) const; void operator%= (const valarray<T>&) const; void operator+= (const valarray<T>&) const; void operator-= (const valarray<T>&) const; void operator^= (const valarray<T>&) const; void operator&= (const valarray<T>&) const; void operator|= (const valarray<T>&) const; void operator<=(const valarray<T>&) const; void operator>=(const valarray<T>&) const; slice_array(const slice_array&); ~slice_array(); const slice_array& operator=(const slice_array&) const; void operator=(const T&) const; slice_array() = delete; / as implied by declaring copy constructor above }; }
1
#
This template is a helper template used by the slice subscript operator slice_array<T> valarray<T>::operator[](slice);
2
#
It has reference semantics to a subset of an array specified by a slice object.
[Example 1: 
The expression a[slice(1, 5, 3)] = b; has the effect of assigning the elements of b to a slice of the elements in a.
For the slice shown, the elements selected from a are
— end example]
🔗
void operator=(const valarray<T>&) const; const slice_array& operator=(const slice_array&) const;
1
#
These assignment operators have reference semantics, assigning the values of the argument array elements to selected elements of the valarray<T> object to which the slice_array object refers.

29.6.5.3 Compound assignment [slice.arr.comp.assign]

🔗
void operator*= (const valarray<T>&) const; void operator/= (const valarray<T>&) const; void operator%= (const valarray<T>&) const; void operator+= (const valarray<T>&) const; void operator-= (const valarray<T>&) const; void operator^= (const valarray<T>&) const; void operator&= (const valarray<T>&) const; void operator|= (const valarray<T>&) const; void operator<=(const valarray<T>&) const; void operator>=(const valarray<T>&) const;
1
#
These compound assignments have reference semantics, applying the indicated operation to the elements of the argument array and selected elements of the valarray<T> object to which the slice_array object refers.
🔗
void operator=(const T&) const;
1
#
This function has reference semantics, assigning the value of its argument to the elements of the valarray<T> object to which the slice_array object refers.

29.6.6 The gslice class [class.gslice]

🔗
namespace std { class gslice { public: gslice(); gslice(size_t s, const valarray<size_t>& l, const valarray<size_t>& d); size_t start() const; valarray<size_t> size() const; valarray<size_t> stride() const; }; }
1
#
This class represents a generalized slice out of an array.
A gslice is defined by a starting offset (s), a set of lengths (
The number of lengths shall equal the number of strides.
2
#
A gslice represents a mapping from a set of indices (
It is useful for building multidimensional array classes using the valarray template, which is one-dimensional.
The set of one-dimensional index values specified by a gslice are
3
#
[Example 1: 
The gslice specification start = 3 length = {2, 4, 3} stride = {19, 4, 1} yields the sequence of one-dimensional indices
That is, the highest-ordered index turns fastest.
— end example]
4
#
It is possible to have degenerate generalized slices in which an address is repeated.
5
#
[Example 2: 
If the stride parameters in the previous example are changed to {1, 1, 1}, the first few elements of the resulting sequence of indices will be
	(0,  0,  0,   3),  
	(0,  0,  1,   4),  
	(0,  0,  2,   5),  
	(0,  1,  0,   4),  
	(0,  1,  1,   5),  
	(0,  1,  2,   6),  
	…
— end example]
6
#
If a degenerate slice is used as the argument to the non-const version of operator[](const gslice&), the behavior is undefined.

29.6.6.2 Constructors [gslice.cons]

🔗
gslice(); gslice(size_t start, const valarray<size_t>& lengths, const valarray<size_t>& strides);
1
#
The default constructor is equivalent to gslice(0, valarray<size_t>(), valarray<size_t>().
The constructor with arguments builds a gslice based on a specification of start, lengths, and strides, as explained in the previous subclause.

29.6.6.3 Access functions [gslice.access]

🔗
size_t start() const; valarray<size_t> size() const; valarray<size_t> stride() const;
1
#
Returns: The representation of the start, lengths, or strides specified for the gslice.
2
#
Complexity: start() is constant time.
size() and stride() are linear in the number of strides.

29.6.7 Class template gslice_array [template.gslice.array]

🔗
namespace std { template<class T> class gslice_array { public: using value_type = T; void operator= (const valarray<T>&) const; void operator*= (const valarray<T>&) const; void operator/= (const valarray<T>&) const; void operator%= (const valarray<T>&) const; void operator+= (const valarray<T>&) const; void operator-= (const valarray<T>&) const; void operator^= (const valarray<T>&) const; void operator&= (const valarray<T>&) const; void operator|= (const valarray<T>&) const; void operator<=(const valarray<T>&) const; void operator>=(const valarray<T>&) const; gslice_array(const gslice_array&); ~gslice_array(); const gslice_array& operator=(const gslice_array&) const; void operator=(const T&) const; gslice_array() = delete; / as implied by declaring copy constructor above }; }
1
#
This template is a helper template used by the gslice subscript operator
🔗
gslice_array<T> valarray<T>::operator[](const gslice&);
2
#
It has reference semantics to a subset of an array specified by a gslice object.
Thus, the expression a[gslice(1, length, stride)] = b has the effect of assigning the elements of b to a generalized slice of the elements in a.
🔗
void operator=(const valarray<T>&) const; const gslice_array& operator=(const gslice_array&) const;
1
#
These assignment operators have reference semantics, assigning the values of the argument array elements to selected elements of the valarray<T> object to which the gslice_array refers.
🔗
void operator*= (const valarray<T>&) const; void operator/= (const valarray<T>&) const; void operator%= (const valarray<T>&) const; void operator+= (const valarray<T>&) const; void operator-= (const valarray<T>&) const; void operator^= (const valarray<T>&) const; void operator&= (const valarray<T>&) const; void operator|= (const valarray<T>&) const; void operator<=(const valarray<T>&) const; void operator>=(const valarray<T>&) const;
1
#
These compound assignments have reference semantics, applying the indicated operation to the elements of the argument array and selected elements of the valarray<T> object to which the gslice_array object refers.
🔗
void operator=(const T&) const;
1
#
This function has reference semantics, assigning the value of its argument to the elements of the valarray<T> object to which the gslice_array object refers.

29.6.8 Class template mask_array [template.mask.array]

🔗
namespace std { template<class T> class mask_array { public: using value_type = T; void operator= (const valarray<T>&) const; void operator*= (const valarray<T>&) const; void operator/= (const valarray<T>&) const; void operator%= (const valarray<T>&) const; void operator+= (const valarray<T>&) const; void operator-= (const valarray<T>&) const; void operator^= (const valarray<T>&) const; void operator&= (const valarray<T>&) const; void operator|= (const valarray<T>&) const; void operator<=(const valarray<T>&) const; void operator>=(const valarray<T>&) const; mask_array(const mask_array&); ~mask_array(); const mask_array& operator=(const mask_array&) const; void operator=(const T&) const; mask_array() = delete; / as implied by declaring copy constructor above }; }
1
#
This template is a helper template used by the mask subscript operator:
🔗
mask_array<T> valarray<T>::operator[](const valarray<bool>&);
2
#
It has reference semantics to a subset of an array specified by a boolean mask.
Thus, the expression a[mask] = b; has the effect of assigning the elements of b to the masked elements in a (those for which the corresponding element in mask is true).
🔗
void operator=(const valarray<T>&) const; const mask_array& operator=(const mask_array&) const;
1
#
These assignment operators have reference semantics, assigning the values of the argument array elements to selected elements of the valarray<T> object to which the mask_array object refers.
🔗
void operator*= (const valarray<T>&) const; void operator/= (const valarray<T>&) const; void operator%= (const valarray<T>&) const; void operator+= (const valarray<T>&) const; void operator-= (const valarray<T>&) const; void operator^= (const valarray<T>&) const; void operator&= (const valarray<T>&) const; void operator|= (const valarray<T>&) const; void operator<=(const valarray<T>&) const; void operator>=(const valarray<T>&) const;
1
#
These compound assignments have reference semantics, applying the indicated operation to the elements of the argument array and selected elements of the valarray<T> object to which the mask_array object refers.
🔗
void operator=(const T&) const;
1
#
This function has reference semantics, assigning the value of its argument to the elements of the valarray<T> object to which the mask_array object refers.

29.6.9 Class template indirect_array [template.indirect.array]

🔗
namespace std { template<class T> class indirect_array { public: using value_type = T; void operator= (const valarray<T>&) const; void operator*= (const valarray<T>&) const; void operator/= (const valarray<T>&) const; void operator%= (const valarray<T>&) const; void operator+= (const valarray<T>&) const; void operator-= (const valarray<T>&) const; void operator^= (const valarray<T>&) const; void operator&= (const valarray<T>&) const; void operator|= (const valarray<T>&) const; void operator<=(const valarray<T>&) const; void operator>=(const valarray<T>&) const; indirect_array(const indirect_array&); ~indirect_array(); const indirect_array& operator=(const indirect_array&) const; void operator=(const T&) const; indirect_array() = delete; / as implied by declaring copy constructor above }; }
1
#
This template is a helper template used by the indirect subscript operator
🔗
indirect_array<T> valarray<T>::operator[](const valarray<size_t>&);
2
#
It has reference semantics to a subset of an array specified by an indirect_array.
Thus, the expression a[​indirect] = b; has the effect of assigning the elements of b to the elements in a whose indices appear in indirect.
🔗
void operator=(const valarray<T>&) const; const indirect_array& operator=(const indirect_array&) const;
1
#
These assignment operators have reference semantics, assigning the values of the argument array elements to selected elements of the valarray<T> object to which it refers.
2
#
If the indirect_array specifies an element in the valarray<T> object to which it refers more than once, the behavior is undefined.
3
#
[Example 1: 
int addr[] = {2, 3, 1, 4}; valarray<size_t> indirect(addr, 5); valarray<double> a(0., 10), b(1., 5); a[indirect] = b; results in undefined behavior since element 4 is specified twice in the indirection.
— end example]
🔗
void operator*= (const valarray<T>&) const; void operator/= (const valarray<T>&) const; void operator%= (const valarray<T>&) const; void operator+= (const valarray<T>&) const; void operator-= (const valarray<T>&) const; void operator^= (const valarray<T>&) const; void operator&= (const valarray<T>&) const; void operator|= (const valarray<T>&) const; void operator<=(const valarray<T>&) const; void operator>=(const valarray<T>&) const;
1
#
These compound assignments have reference semantics, applying the indicated operation to the elements of the argument array and selected elements of the valarray<T> object to which the indirect_array object refers.
2
#
If the indirect_array specifies an element in the valarray<T> object to which it refers more than once, the behavior is undefined.
🔗
void operator=(const T&) const;
1
#
This function has reference semantics, assigning the value of its argument to the elements of the valarray<T> object to which the indirect_array object refers.
1
#
The iterator type is a type that meets the requirements of a mutable Cpp17RandomAccessIterator ([random.access.iterators]) and models contiguous_iterator ([iterator.concept.contiguous]).
Its value_type is the template parameter T and its reference type is T&.
The const_iterator type meets the requirements of a constant Cpp17RandomAccessIterator and models contiguous_iterator.
Its value_type is the template parameter T and its reference type is const T&.
2
#
The iterators returned by begin and end for an array are guaranteed to be valid until the member function resize(size_t, T) is called for that array or until the lifetime of that array ends, whichever happens first.
🔗
iterator begin(); const_iterator begin() const;
3
#
Returns: An iterator referencing the first value in the array.
🔗
iterator end(); const_iterator end() const;
4
#
Returns: An iterator referencing one past the last value in the array.

29.7 Mathematical functions for floating-point types [c.math]

29.7.1 Header <cmath> synopsis [cmath.syn]

🔗
#define HUGE_VAL see below #define HUGE_VALF see below #define HUGE_VALL see below #define INFINITY see below #define NAN see below #define FP_INFINITE see below #define FP_NAN see below #define FP_NORMAL see below #define FP_SUBNORMAL see below #define FP_ZERO see below #define FP_FAST_FMA see below #define FP_FAST_FMAF see below #define FP_FAST_FMAL see below #define FP_ILOGB0 see below #define FP_ILOGBNAN see below #define MATH_ERRNO see below #define MATH_ERREXCEPT see below #define math_errhandling see below namespace std { using float_t = see below; using double_t = see below; constexpr floating-point-type acos(floating-point-type x); constexpr float acosf(float x); constexpr long double acosl(long double x); constexpr floating-point-type asin(floating-point-type x); constexpr float asinf(float x); constexpr long double asinl(long double x); constexpr floating-point-type atan(floating-point-type x); constexpr float atanf(float x); constexpr long double atanl(long double x); constexpr floating-point-type atan2(floating-point-type y, floating-point-type x); constexpr float atan2f(float y, float x); constexpr long double atan2l(long double y, long double x); constexpr floating-point-type cos(floating-point-type x); constexpr float cosf(float x); constexpr long double cosl(long double x); constexpr floating-point-type sin(floating-point-type x); constexpr float sinf(float x); constexpr long double sinl(long double x); constexpr floating-point-type tan(floating-point-type x); constexpr float tanf(float x); constexpr long double tanl(long double x); constexpr floating-point-type acosh(floating-point-type x); constexpr float acoshf(float x); constexpr long double acoshl(long double x); constexpr floating-point-type asinh(floating-point-type x); constexpr float asinhf(float x); constexpr long double asinhl(long double x); constexpr floating-point-type atanh(floating-point-type x); constexpr float atanhf(float x); constexpr long double atanhl(long double x); constexpr floating-point-type cosh(floating-point-type x); constexpr float coshf(float x); constexpr long double coshl(long double x); constexpr floating-point-type sinh(floating-point-type x); constexpr float sinhf(float x); constexpr long double sinhl(long double x); constexpr floating-point-type tanh(floating-point-type x); constexpr float tanhf(float x); constexpr long double tanhl(long double x); constexpr floating-point-type exp(floating-point-type x); constexpr float expf(float x); constexpr long double expl(long double x); constexpr floating-point-type exp2(floating-point-type x); constexpr float exp2f(float x); constexpr long double exp2l(long double x); constexpr floating-point-type expm1(floating-point-type x); constexpr float expm1f(float x); constexpr long double expm1l(long double x); constexpr floating-point-type frexp(floating-point-type value, int* exp); constexpr float frexpf(float value, int* exp); constexpr long double frexpl(long double value, int* exp); constexpr int ilogb(floating-point-type x); constexpr int ilogbf(float x); constexpr int ilogbl(long double x); constexpr floating-point-type ldexp(floating-point-type x, int exp); constexpr float ldexpf(float x, int exp); constexpr long double ldexpl(long double x, int exp); constexpr floating-point-type log(floating-point-type x); constexpr float logf(float x); constexpr long double logl(long double x); constexpr floating-point-type log10(floating-point-type x); constexpr float log10f(float x); constexpr long double log10l(long double x); constexpr floating-point-type log1p(floating-point-type x); constexpr float log1pf(float x); constexpr long double log1pl(long double x); constexpr floating-point-type log2(floating-point-type x); constexpr float log2f(float x); constexpr long double log2l(long double x); constexpr floating-point-type logb(floating-point-type x); constexpr float logbf(float x); constexpr long double logbl(long double x); constexpr floating-point-type modf(floating-point-type value, floating-point-type* iptr); constexpr float modff(float value, float* iptr); constexpr long double modfl(long double value, long double* iptr); constexpr floating-point-type scalbn(floating-point-type x, int n); constexpr float scalbnf(float x, int n); constexpr long double scalbnl(long double x, int n); constexpr floating-point-type scalbln(floating-point-type x, long int n); constexpr float scalblnf(float x, long int n); constexpr long double scalblnl(long double x, long int n); constexpr floating-point-type cbrt(floating-point-type x); constexpr float cbrtf(float x); constexpr long double cbrtl(long double x); / [c.math.abs], absolute values constexpr int abs(int j); / freestanding constexpr long int abs(long int j); / freestanding constexpr long int abs(long long int j); / freestanding constexpr floating-point-type abs(floating-point-type j); / freestanding-deleted constexpr floating-point-type fabs(floating-point-type x); constexpr float fabsf(float x); constexpr long double fabsl(long double x); constexpr floating-point-type hypot(floating-point-type x, floating-point-type y); constexpr float hypotf(float x, float y); constexpr long double hypotl(long double x, long double y); / [c.math.hypot3], three-dimensional hypotenuse constexpr floating-point-type hypot(floating-point-type x, floating-point-type y, floating-point-type z); constexpr floating-point-type pow(floating-point-type x, floating-point-type y); constexpr float powf(float x, float y); constexpr long double powl(long double x, long double y); constexpr floating-point-type sqrt(floating-point-type x); constexpr float sqrtf(float x); constexpr long double sqrtl(long double x); constexpr floating-point-type erf(floating-point-type x); constexpr float erff(float x); constexpr long double erfl(long double x); constexpr floating-point-type erfc(floating-point-type x); constexpr float erfcf(float x); constexpr long double erfcl(long double x); constexpr floating-point-type lgamma(floating-point-type x); constexpr float lgammaf(float x); constexpr long double lgammal(long double x); constexpr floating-point-type tgamma(floating-point-type x); constexpr float tgammaf(float x); constexpr long double tgammal(long double x); constexpr floating-point-type ceil(floating-point-type x); constexpr float ceilf(float x); constexpr long double ceill(long double x); constexpr floating-point-type floor(floating-point-type x); constexpr float floorf(float x); constexpr long double floorl(long double x); floating-point-type nearbyint(floating-point-type x); float nearbyintf(float x); long double nearbyintl(long double x); floating-point-type rint(floating-point-type x); float rintf(float x); long double rintl(long double x); long int lrint(floating-point-type x); long int lrintf(float x); long int lrintl(long double x); long long int llrint(floating-point-type x); long long int llrintf(float x); long long int llrintl(long double x); constexpr floating-point-type round(floating-point-type x); constexpr float roundf(float x); constexpr long double roundl(long double x); constexpr long int lround(floating-point-type x); constexpr long int lroundf(float x); constexpr long int lroundl(long double x); constexpr long int llround(floating-point-type x); constexpr long int llroundf(float x); constexpr long int llroundl(long double x); constexpr floating-point-type trunc(floating-point-type x); constexpr float truncf(float x); constexpr long double truncl(long double x); constexpr floating-point-type fmod(floating-point-type x, floating-point-type y); constexpr float fmodf(float x, float y); constexpr long double fmodl(long double x, long double y); constexpr floating-point-type remainder(floating-point-type x, floating-point-type y); constexpr float remainderf(float x, float y); constexpr long double remainderl(long double x, long double y); constexpr floating-point-type remquo(floating-point-type x, floating-point-type y, int* quo); constexpr float remquof(float x, float y, int* quo); constexpr long double remquol(long double x, long double y, int* quo); constexpr floating-point-type copysign(floating-point-type x, floating-point-type y); constexpr float copysignf(float x, float y); constexpr long double copysignl(long double x, long double y); double nan(const char* tagp); float nanf(const char* tagp); long double nanl(const char* tagp); constexpr floating-point-type nextafter(floating-point-type x, floating-point-type y); constexpr float nextafterf(float x, float y); constexpr long double nextafterl(long double x, long double y); constexpr floating-point-type nexttoward(floating-point-type x, long double y); constexpr float nexttowardf(float x, long double y); constexpr long double nexttowardl(long double x, long double y); constexpr floating-point-type nextup(floating-point-type x); constexpr float nextupf(float x); constexpr long double nextupl(long double x); constexpr floating-point-type nextdown(floating-point-type x); constexpr float nextdownf(float x); constexpr long double nextdownl(long double x); constexpr floating-point-type fdim(floating-point-type x, floating-point-type y); constexpr float fdimf(float x, float y); constexpr long double fdiml(long double x, long double y); constexpr floating-point-type fmax(floating-point-type x, floating-point-type y); constexpr float fmaxf(float x, float y); constexpr long double fmaxl(long double x, long double y); constexpr floating-point-type fmin(floating-point-type x, floating-point-type y); constexpr float fminf(float x, float y); constexpr long double fminl(long double x, long double y); constexpr floating-point-type fmaximum(floating-point-type x, floating-point-type y); constexpr floating-point-type fmaximum_num(floating-point-type x, floating-point-type y); constexpr floating-point-type fminimum(floating-point-type x, floating-point-type y); constexpr floating-point-type fminimum_num(floating-point-type x, floating-point-type y); constexpr floating-point-type fma(floating-point-type x, floating-point-type y, floating-point-type z); constexpr float fmaf(float x, float y, float z); constexpr long double fmal(long double x, long double y, long double z); / [c.math.lerp], linear interpolation constexpr floating-point-type lerp(floating-point-type a, floating-point-type b, floating-point-type t) noexcept; / [c.math.fpclass], classification / comparison functions constexpr int fpclassify(floating-point-type x); constexpr bool isfinite(floating-point-type x); constexpr bool isinf(floating-point-type x); constexpr bool isnan(floating-point-type x); constexpr bool isnormal(floating-point-type x); constexpr bool signbit(floating-point-type x); constexpr bool isgreater(floating-point-type x, floating-point-type y); constexpr bool isgreaterequal(floating-point-type x, floating-point-type y); constexpr bool isless(floating-point-type x, floating-point-type y); constexpr bool islessequal(floating-point-type x, floating-point-type y); constexpr bool islessgreater(floating-point-type x, floating-point-type y); constexpr bool isunordered(floating-point-type x, floating-point-type y); / [sf.cmath], mathematical special functions / [sf.cmath.assoc.laguerre], associated Laguerre polynomials floating-point-type assoc_laguerre(unsigned n, unsigned m, floating-point-type x); float assoc_laguerref(unsigned n, unsigned m, float x); long double assoc_laguerrel(unsigned n, unsigned m, long double x); / [sf.cmath.assoc.legendre], associated Legendre functions floating-point-type assoc_legendre(unsigned l, unsigned m, floating-point-type x); float assoc_legendref(unsigned l, unsigned m, float x); long double assoc_legendrel(unsigned l, unsigned m, long double x); / [sf.cmath.beta], beta function floating-point-type beta(floating-point-type x, floating-point-type y); float betaf(float x, float y); long double betal(long double x, long double y); / [sf.cmath.comp.ellint.1], complete elliptic integral of the first kind floating-point-type comp_ellint_1(floating-point-type k); float comp_ellint_1f(float k); long double comp_ellint_1l(long double k); / [sf.cmath.comp.ellint.2], complete elliptic integral of the second kind floating-point-type comp_ellint_2(floating-point-type k); float comp_ellint_2f(float k); long double comp_ellint_2l(long double k); / [sf.cmath.comp.ellint.3], complete elliptic integral of the third kind floating-point-type comp_ellint_3(floating-point-type k, floating-point-type nu); float comp_ellint_3f(float k, float nu); long double comp_ellint_3l(long double k, long double nu); / [sf.cmath.cyl.bessel.i], regular modified cylindrical Bessel functions floating-point-type cyl_bessel_i(floating-point-type nu, floating-point-type x); float cyl_bessel_if(float nu, float x); long double cyl_bessel_il(long double nu, long double x); / [sf.cmath.cyl.bessel.j], cylindrical Bessel functions of the first kind floating-point-type cyl_bessel_j(floating-point-type nu, floating-point-type x); float cyl_bessel_jf(float nu, float x); long double cyl_bessel_jl(long double nu, long double x); / [sf.cmath.cyl.bessel.k], irregular modified cylindrical Bessel functions floating-point-type cyl_bessel_k(floating-point-type nu, floating-point-type x); float cyl_bessel_kf(float nu, float x); long double cyl_bessel_kl(long double nu, long double x); / [sf.cmath.cyl.neumann], cylindrical Neumann functions / cylindrical Bessel functions of the second kind floating-point-type cyl_neumann(floating-point-type nu, floating-point-type x); float cyl_neumannf(float nu, float x); long double cyl_neumannl(long double nu, long double x); / [sf.cmath.ellint.1], incomplete elliptic integral of the first kind floating-point-type ellint_1(floating-point-type k, floating-point-type phi); float ellint_1f(float k, float phi); long double ellint_1l(long double k, long double phi); / [sf.cmath.ellint.2], incomplete elliptic integral of the second kind floating-point-type ellint_2(floating-point-type k, floating-point-type phi); float ellint_2f(float k, float phi); long double ellint_2l(long double k, long double phi); / [sf.cmath.ellint.3], incomplete elliptic integral of the third kind floating-point-type ellint_3(floating-point-type k, floating-point-type nu, floating-point-type phi); float ellint_3f(float k, float nu, float phi); long double ellint_3l(long double k, long double nu, long double phi); / [sf.cmath.expint], exponential integral floating-point-type expint(floating-point-type x); float expintf(float x); long double expintl(long double x); / [sf.cmath.hermite], Hermite polynomials floating-point-type hermite(unsigned n, floating-point-type x); float hermitef(unsigned n, float x); long double hermitel(unsigned n, long double x); / [sf.cmath.laguerre], Laguerre polynomials floating-point-type laguerre(unsigned n, floating-point-type x); float laguerref(unsigned n, float x); long double laguerrel(unsigned n, long double x); / [sf.cmath.legendre], Legendre polynomials floating-point-type legendre(unsigned l, floating-point-type x); float legendref(unsigned l, float x); long double legendrel(unsigned l, long double x); / [sf.cmath.riemann.zeta], Riemann zeta function floating-point-type riemann_zeta(floating-point-type x); float riemann_zetaf(float x); long double riemann_zetal(long double x); / [sf.cmath.sph.bessel], spherical Bessel functions of the first kind floating-point-type sph_bessel(unsigned n, floating-point-type x); float sph_besself(unsigned n, float x); long double sph_bessell(unsigned n, long double x); / [sf.cmath.sph.legendre], spherical associated Legendre functions floating-point-type sph_legendre(unsigned l, unsigned m, floating-point-type theta); float sph_legendref(unsigned l, unsigned m, float theta); long double sph_legendrel(unsigned l, unsigned m, long double theta); / [sf.cmath.sph.neumann], spherical Neumann functions; / spherical Bessel functions of the second kind floating-point-type sph_neumann(unsigned n, floating-point-type x); float sph_neumannf(unsigned n, float x); long double sph_neumannl(unsigned n, long double x); }
1
#
The contents and meaning of the header <cmath> are a subset of the C standard library header <math.h> and only the declarations shown in the synopsis above are present, with the addition of a three-dimensional hypotenuse function, a linear interpolation function, and the mathematical special functions described in [sf.cmath].
[Note 1: 
Several functions have additional overloads in this document, but they have the same behavior as in the C standard library.
— end note]
2
#
For each function with at least one parameter of type floating-point-type, the implementation provides an overload for each cv-unqualified floating-point type ([basic.fundamental]) where all uses of floating-point-type in the function signature are replaced with that floating-point type.
3
#
For each function with at least one parameter of type floating-point-type other than abs, the implementation also provides additional overloads sufficient to ensure that, if every argument corresponding to a floating-point-type parameter has arithmetic type, then every such argument is effectively cast to the floating-point type with the greatest floating-point conversion rank and greatest floating-point conversion subrank among the types of all such arguments, where arguments of integer type are considered to have the same floating-point conversion rank as double.
If no such floating-point type with the greatest rank and subrank exists, then overload resolution does not result in a usable candidate ([over.match.general]) from the overloads provided by the implementation.
4
#
An invocation of nexttoward is ill-formed if the argument corresponding to the floating-point-type parameter has extended floating-point type.
See also: ISO/IEC 9899:2024, 7.12

29.7.2 Absolute values [c.math.abs]

1
#
[Note 1: 
The headers <cstdlib> and <cmath> declare the functions described in this subclause.
— end note]
🔗
constexpr int abs(int j); constexpr long int abs(long int j); constexpr long int abs(long long int j);
2
#
Effects: These functions have the semantics specified in the C standard library for the functions abs, labs, and llabs, respectively.
3
#
Remarks: If abs is called with an argument of type X for which is_unsigned_v<X> is true and if X cannot be converted to int by integral promotion, the program is ill-formed.
[Note 2: 
Allowing arguments that can be promoted to int provides compatibility with C.
— end note]
🔗
constexpr floating-point-type abs(floating-point-type x);
4
#
Returns: The absolute value of x.
See also: ISO/IEC 9899:2024, 7.12.8.3, 7.24.7.1

29.7.3 Three-dimensional hypotenuse [c.math.hypot3]

🔗
constexpr floating-point-type hypot(floating-point-type x, floating-point-type y, floating-point-type z);
1
#
Returns:

29.7.4 Linear interpolation [c.math.lerp]

🔗
constexpr floating-point-type lerp(floating-point-type a, floating-point-type b, floating-point-type t) noexcept;
1
#
Remarks: Let r be the value returned.
If isfinite(a) && isfinite(b), then:
  • (2.1)
    If t == 0, then r == a.
  • (2.2)
    If t == 1, then r == b.
  • (2.3)
    If t >= 0 && t <= 1, then isfinite(r).
  • (2.4)
    If isfinite(t) && a == b, then r == a.
  • (2.5)
    If isfinite(t) || !isnan(t) && b - a != 0, then !isnan(r).
Let CMP(x,y) be 1 if x > y, -1 if x < y, and 0 otherwise.
For any t1 and t2, the product of CMP(lerp(a, b, t2), lerp(a, b, t1)), CMP(t2, t1), and CMP(b, a) is non-negative.

29.7.5 Classification / comparison functions [c.math.fpclass]

1
#
The classification / comparison functions behave the same as the C macros with the corresponding names defined in the C standard library.
See also: ISO/IEC 9899:2024, 7.12.4, 7.12.18

29.7.6 Mathematical special functions [sf.cmath]

1
#
If any argument value to any of the functions specified in [sf.cmath] is a NaN (Not a Number), the function shall return a NaN but it shall not report a domain error.
Otherwise, the function shall report a domain error for just those argument values for which:
  • (1.1)
    the function description's Returns: element explicitly specifies a domain and those argument values fall outside the specified domain, or
  • (1.2)
    the corresponding mathematical function value has a nonzero imaginary component, or
  • (1.3)
    the corresponding mathematical function is not mathematically defined.245
2
#
Unless otherwise specified, each function is defined for all finite values, for negative infinity, and for positive infinity.
245)245)
A mathematical function is mathematically defined for a given set of argument values (a) if it is explicitly defined for that set of argument values, or (b) if its limiting value exists and does not depend on the direction of approach.

29.7.6.2 Associated Laguerre polynomials [sf.cmath.assoc.laguerre]

🔗
floating-point-type assoc_laguerre(unsigned n, unsigned m, floating-point-type x); float assoc_laguerref(unsigned n, unsigned m, float x); long double assoc_laguerrel(unsigned n, unsigned m, long double x);
1
#
Effects: These functions compute the associated Laguerre polynomials of their respective arguments n, m, and x.
2
#
Returns:
3
#
Remarks: The effect of calling each of these functions is implementation-defined if n >= 128 or if m >= 128.

29.7.6.3 Associated Legendre functions [sf.cmath.assoc.legendre]

🔗
floating-point-type assoc_legendre(unsigned l, unsigned m, floating-point-type x); float assoc_legendref(unsigned l, unsigned m, float x); long double assoc_legendrel(unsigned l, unsigned m, long double x);
1
#
Effects: These functions compute the associated Legendre functions of their respective arguments l, m, and x.
2
#
Returns:
3
#
Remarks: The effect of calling each of these functions is implementation-defined if l >= 128.
🔗
floating-point-type beta(floating-point-type x, floating-point-type y); float betaf(float x, float y); long double betal(long double x, long double y);
1
#
Effects: These functions compute the beta function of their respective arguments x and y.
2
#
Returns:

29.7.6.5 Complete elliptic integral of the first kind [sf.cmath.comp.ellint.1]

🔗
floating-point-type comp_ellint_1(floating-point-type k); float comp_ellint_1f(float k); long double comp_ellint_1l(long double k);
1
#
Effects: These functions compute the complete elliptic integral of the first kind of their respective arguments k.
2
#
Returns: K(k), where K is given by Formula 29.25 and k is k.
3
#

29.7.6.6 Complete elliptic integral of the second kind [sf.cmath.comp.ellint.2]

🔗
floating-point-type comp_ellint_2(floating-point-type k); float comp_ellint_2f(float k); long double comp_ellint_2l(long double k);
1
#
Effects: These functions compute the complete elliptic integral of the second kind of their respective arguments k.
2
#
Returns: E(k), where E is given by Formula 29.26 and k is k.
3
#

29.7.6.7 Complete elliptic integral of the third kind [sf.cmath.comp.ellint.3]

🔗
floating-point-type comp_ellint_3(floating-point-type k, floating-point-type nu); float comp_ellint_3f(float k, float nu); long double comp_ellint_3l(long double k, long double nu);
1
#
Effects: These functions compute the complete elliptic integral of the third kind of their respective arguments k and nu.
2
#
Returns:
3
#

29.7.6.8 Regular modified cylindrical Bessel functions [sf.cmath.cyl.bessel.i]

🔗
floating-point-type cyl_bessel_i(floating-point-type nu, floating-point-type x); float cyl_bessel_if(float nu, float x); long double cyl_bessel_il(long double nu, long double x);
1
#
Effects: These functions compute the regular modified cylindrical Bessel functions of their respective arguments nu and x.
2
#
Returns:
3
#
Remarks: The effect of calling each of these functions is implementation-defined if nu >= 128.
4
#

29.7.6.9 Cylindrical Bessel functions of the first kind [sf.cmath.cyl.bessel.j]

🔗
floating-point-type cyl_bessel_j(floating-point-type nu, floating-point-type x); float cyl_bessel_jf(float nu, float x); long double cyl_bessel_jl(long double nu, long double x);
1
#
Effects: These functions compute the cylindrical Bessel functions of the first kind of their respective arguments nu and x.
2
#
Returns:
3
#
Remarks: The effect of calling each of these functions is implementation-defined if nu >= 128.

29.7.6.10 Irregular modified cylindrical Bessel functions [sf.cmath.cyl.bessel.k]

🔗
floating-point-type cyl_bessel_k(floating-point-type nu, floating-point-type x); float cyl_bessel_kf(float nu, float x); long double cyl_bessel_kl(long double nu, long double x);
1
#
Effects: These functions compute the irregular modified cylindrical Bessel functions of their respective arguments nu and x.
2
#
Returns:
3
#
Remarks: The effect of calling each of these functions is implementation-defined if nu >= 128.
4
#

29.7.6.11 Cylindrical Neumann functions [sf.cmath.cyl.neumann]

🔗
floating-point-type cyl_neumann(floating-point-type nu, floating-point-type x); float cyl_neumannf(float nu, float x); long double cyl_neumannl(long double nu, long double x);
1
#
Effects: These functions compute the cylindrical Neumann functions, also known as the cylindrical Bessel functions of the second kind, of their respective arguments nu and x.
2
#
Returns:
3
#
Remarks: The effect of calling each of these functions is implementation-defined if nu >= 128.
4
#

29.7.6.12 Incomplete elliptic integral of the first kind [sf.cmath.ellint.1]

🔗
floating-point-type ellint_1(floating-point-type k, floating-point-type phi); float ellint_1f(float k, float phi); long double ellint_1l(long double k, long double phi);
1
#
Effects: These functions compute the incomplete elliptic integral of the first kind of their respective arguments k and phi (phi measured in radians).
2
#
Returns: F(k, φ), where F is given by Formula 29.32, k is k, and φ is phi.

29.7.6.13 Incomplete elliptic integral of the second kind [sf.cmath.ellint.2]

🔗
floating-point-type ellint_2(floating-point-type k, floating-point-type phi); float ellint_2f(float k, float phi); long double ellint_2l(long double k, long double phi);
1
#
Effects: These functions compute the incomplete elliptic integral of the second kind of their respective arguments k and phi (phi measured in radians).
2
#
Returns: E(k, φ), where E is given by Formula 29.33, k is k, and φ is phi.

29.7.6.14 Incomplete elliptic integral of the third kind [sf.cmath.ellint.3]

🔗
floating-point-type ellint_3(floating-point-type k, floating-point-type nu, floating-point-type phi); float ellint_3f(float k, float nu, float phi); long double ellint_3l(long double k, long double nu, long double phi);
1
#
Effects: These functions compute the incomplete elliptic integral of the third kind of their respective arguments k, nu, and phi (phi measured in radians).
2
#
Returns:

29.7.6.15 Exponential integral [sf.cmath.expint]

🔗
floating-point-type expint(floating-point-type x); float expintf(float x); long double expintl(long double x);
1
#
Effects: These functions compute the exponential integral of their respective arguments x.
2
#
Returns: Ei(x), where Ei is given by Formula 29.35 and x is x.

29.7.6.16 Hermite polynomials [sf.cmath.hermite]

🔗
floating-point-type hermite(unsigned n, floating-point-type x); float hermitef(unsigned n, float x); long double hermitel(unsigned n, long double x);
1
#
Effects: These functions compute the Hermite polynomials of their respective arguments n and x.
2
#
Returns:
3
#
Remarks: The effect of calling each of these functions is implementation-defined if n >= 128.

29.7.6.17 Laguerre polynomials [sf.cmath.laguerre]

🔗
floating-point-type laguerre(unsigned n, floating-point-type x); float laguerref(unsigned n, float x); long double laguerrel(unsigned n, long double x);
1
#
Effects: These functions compute the Laguerre polynomials of their respective arguments n and x.
2
#
Returns:
3
#
Remarks: The effect of calling each of these functions is implementation-defined if n >= 128.

29.7.6.18 Legendre polynomials [sf.cmath.legendre]

🔗
floating-point-type legendre(unsigned l, floating-point-type x); float legendref(unsigned l, float x); long double legendrel(unsigned l, long double x);
1
#
Effects: These functions compute the Legendre polynomials of their respective arguments l and x.
2
#
Returns:
3
#
Remarks: The effect of calling each of these functions is implementation-defined if l >= 128.

29.7.6.19 Riemann zeta function [sf.cmath.riemann.zeta]

🔗
floating-point-type riemann_zeta(floating-point-type x); float riemann_zetaf(float x); long double riemann_zetal(long double x);
1
#
Effects: These functions compute the Riemann zeta function of their respective arguments x.
2
#
Returns: ζ(x), where ζ is given by Formula 29.39 and x is x.

29.7.6.20 Spherical Bessel functions of the first kind [sf.cmath.sph.bessel]

🔗
floating-point-type sph_bessel(unsigned n, floating-point-type x); float sph_besself(unsigned n, float x); long double sph_bessell(unsigned n, long double x);
1
#
Effects: These functions compute the spherical Bessel functions of the first kind of their respective arguments n and x.
2
#
Returns:
3
#
Remarks: The effect of calling each of these functions is implementation-defined if n >= 128.
4
#

29.7.6.21 Spherical associated Legendre functions [sf.cmath.sph.legendre]

🔗
floating-point-type sph_legendre(unsigned l, unsigned m, floating-point-type theta); float sph_legendref(unsigned l, unsigned m, float theta); long double sph_legendrel(unsigned l, unsigned m, long double theta);
1
#
Effects: These functions compute the spherical associated Legendre functions of their respective arguments l, m, and theta (theta measured in radians).
2
#
Returns:
3
#
Remarks: The effect of calling each of these functions is implementation-defined if l >= 128.
4
#

29.7.6.22 Spherical Neumann functions [sf.cmath.sph.neumann]

🔗
floating-point-type sph_neumann(unsigned n, floating-point-type x); float sph_neumannf(unsigned n, float x); long double sph_neumannl(unsigned n, long double x);
1
#
Effects: These functions compute the spherical Neumann functions, also known as the spherical Bessel functions of the second kind, of their respective arguments n and x.
2
#
Returns:
3
#
Remarks: The effect of calling each of these functions is implementation-defined if n >= 128.
4
#

29.8 Numbers [numbers]

29.8.1 Header <numbers> synopsis [numbers.syn]

🔗
namespace std::numbers { template<class T> constexpr T e_v = unspecified; template<class T> constexpr T log2e_v = unspecified; template<class T> constexpr T log10e_v = unspecified; template<class T> constexpr T pi_v = unspecified; template<class T> constexpr T inv_pi_v = unspecified; template<class T> constexpr T inv_sqrtpi_v = unspecified; template<class T> constexpr T ln2_v = unspecified; template<class T> constexpr T ln10_v = unspecified; template<class T> constexpr T sqrt2_v = unspecified; template<class T> constexpr T sqrt3_v = unspecified; template<class T> constexpr T inv_sqrt3_v = unspecified; template<class T> constexpr T egamma_v = unspecified; template<class T> constexpr T phi_v = unspecified; template<floating_point T> constexpr T e_v<T> = see below; template<floating_point T> constexpr T log2e_v<T> = see below; template<floating_point T> constexpr T log10e_v<T> = see below; template<floating_point T> constexpr T pi_v<T> = see below; template<floating_point T> constexpr T inv_pi_v<T> = see below; template<floating_point T> constexpr T inv_sqrtpi_v<T> = see below; template<floating_point T> constexpr T ln2_v<T> = see below; template<floating_point T> constexpr T ln10_v<T> = see below; template<floating_point T> constexpr T sqrt2_v<T> = see below; template<floating_point T> constexpr T sqrt3_v<T> = see below; template<floating_point T> constexpr T inv_sqrt3_v<T> = see below; template<floating_point T> constexpr T egamma_v<T> = see below; template<floating_point T> constexpr T phi_v<T> = see below; inline constexpr double e = e_v<double>; inline constexpr double log2e = log2e_v<double>; inline constexpr double log10e = log10e_v<double>; inline constexpr double pi = pi_v<double>; inline constexpr double inv_pi = inv_pi_v<double>; inline constexpr double inv_sqrtpi = inv_sqrtpi_v<double>; inline constexpr double ln2 = ln2_v<double>; inline constexpr double ln10 = ln10_v<double>; inline constexpr double sqrt2 = sqrt2_v<double>; inline constexpr double sqrt3 = sqrt3_v<double>; inline constexpr double inv_sqrt3 = inv_sqrt3_v<double>; inline constexpr double egamma = egamma_v<double>; inline constexpr double phi = phi_v<double>; }

29.8.2 Mathematical constants [math.constants]

1
#
The library-defined partial specializations of mathematical constant variable templates are initialized with the nearest representable values of e,
2
#
Pursuant to [namespace.std], a program may partially or explicitly specialize a mathematical constant variable template provided that the specialization depends on a program-defined type.
3
#
A program that instantiates a primary template of a mathematical constant variable template is ill-formed.

29.9 Basic linear algebra algorithms [linalg]

1
#
Subclause [linalg] defines basic linear algebra algorithms.
The algorithms that access the elements of arrays view those elements through mdspan ([views.multidim]).

29.9.2 Header <linalg> synopsis [linalg.syn]

🔗
namespace std::linalg { / [linalg.tags.order], storage order tags struct column_major_t; inline constexpr column_major_t column_major; struct row_major_t; inline constexpr row_major_t row_major; / [linalg.tags.triangle], triangle tags struct upper_triangle_t; inline constexpr upper_triangle_t upper_triangle; struct lower_triangle_t; inline constexpr lower_triangle_t lower_triangle; / [linalg.tags.diagonal], diagonal tags struct implicit_unit_diagonal_t; inline constexpr implicit_unit_diagonal_t implicit_unit_diagonal; struct explicit_diagonal_t; inline constexpr explicit_diagonal_t explicit_diagonal; / [linalg.layout.packed], class template layout_blas_packed template<class Triangle, class StorageOrder> class layout_blas_packed; / [linalg.helpers], exposition-only helpers / [linalg.helpers.concepts], linear algebra argument concepts template<class T> constexpr bool is-mdspan = see below; / exposition only template<class T> concept in-vector = see below; / exposition only template<class T> concept out-vector = see below; / exposition only template<class T> concept inout-vector = see below; / exposition only template<class T> concept in-matrix = see below; / exposition only template<class T> concept out-matrix = see below; / exposition only template<class T> concept inout-matrix = see below; / exposition only template<class T> concept possibly-packed-out-matrix = see below; / exposition only template<class T> concept in-object = see below; / exposition only template<class T> concept out-object = see below; / exposition only template<class T> concept inout-object = see below; / exposition only template<class T> concept scalar = see below; / exposition only / [linalg.scaled], scaled in-place transformation / [linalg.scaled.scaledaccessor], class template scaled_accessor template<class ScalingFactor, class NestedAccessor> class scaled_accessor; / [linalg.scaled.scaled], function template scaled template<class ScalingFactor, class ElementType, class Extents, class Layout, class Accessor> constexpr auto scaled(ScalingFactor alpha, mdspan<ElementType, Extents, Layout, Accessor> x); / [linalg.conj], conjugated in-place transformation / [linalg.conj.conjugatedaccessor], class template conjugated_accessor template<class NestedAccessor> class conjugated_accessor; / [linalg.conj.conjugated], function template conjugated template<class ElementType, class Extents, class Layout, class Accessor> constexpr auto conjugated(mdspan<ElementType, Extents, Layout, Accessor> a); / [linalg.transp], transpose in-place transformation / [linalg.transp.layout.transpose], class template layout_transpose template<class Layout> class layout_transpose; / [linalg.transp.transposed], function template transposed template<class ElementType, class Extents, class Layout, class Accessor> constexpr auto transposed(mdspan<ElementType, Extents, Layout, Accessor> a); / [linalg.conjtransposed], conjugated transpose in-place transformation template<class ElementType, class Extents, class Layout, class Accessor> constexpr auto conjugate_transposed(mdspan<ElementType, Extents, Layout, Accessor> a); / [linalg.algs.blas1], BLAS 1 algorithms / [linalg.algs.blas1.givens], Givens rotations / [linalg.algs.blas1.givens.lartg], compute Givens rotation template<class Real> struct setup_givens_rotation_result { Real c; Real s; Real r; }; template<class Real> struct setup_givens_rotation_result<complex<Real>> { Real c; complex<Real> s; complex<Real> r; }; template<class Real> setup_givens_rotation_result<Real> setup_givens_rotation(Real a, Real b) noexcept; template<class Real> setup_givens_rotation_result<complex<Real>> setup_givens_rotation(complex<Real> a, complex<Real> b) noexcept; / [linalg.algs.blas1.givens.rot], apply computed Givens rotation template<inout-vector InOutVec1, inout-vector InOutVec2, class Real> void apply_givens_rotation(InOutVec1 x, InOutVec2 y, Real c, Real s); template<class ExecutionPolicy, inout-vector InOutVec1, inout-vector InOutVec2, class Real> void apply_givens_rotation(ExecutionPolicy&& exec, InOutVec1 x, InOutVec2 y, Real c, Real s); template<inout-vector InOutVec1, inout-vector InOutVec2, class Real> void apply_givens_rotation(InOutVec1 x, InOutVec2 y, Real c, complex<Real> s); template<class ExecutionPolicy, inout-vector InOutVec1, inout-vector InOutVec2, class Real> void apply_givens_rotation(ExecutionPolicy&& exec, InOutVec1 x, InOutVec2 y, Real c, complex<Real> s); / [linalg.algs.blas1.swap], swap elements template<inout-object InOutObj1, inout-object InOutObj2> void swap_elements(InOutObj1 x, InOutObj2 y); template<class ExecutionPolicy, inout-object InOutObj1, inout-object InOutObj2> void swap_elements(ExecutionPolicy&& exec, InOutObj1 x, InOutObj2 y); / [linalg.algs.blas1.scal], multiply elements by scalar template<scalar Scalar, inout-object InOutObj> void scale(Scalar alpha, InOutObj x); template<class ExecutionPolicy, scalar Scalar, inout-object InOutObj> void scale(ExecutionPolicy&& exec, Scalar alpha, InOutObj x); / [linalg.algs.blas1.copy], copy elements template<in-object InObj, out-object OutObj> void copy(InObj x, OutObj y); template<class ExecutionPolicy, in-object InObj, out-object OutObj> void copy(ExecutionPolicy&& exec, InObj x, OutObj y); / [linalg.algs.blas1.add], add elementwise template<in-object InObj1, in-object InObj2, out-object OutObj> void add(InObj1 x, InObj2 y, OutObj z); template<class ExecutionPolicy, in-object InObj1, in-object InObj2, out-object OutObj> void add(ExecutionPolicy&& exec, InObj1 x, InObj2 y, OutObj z); / [linalg.algs.blas1.dot], dot product of two vectors template<in-vector InVec1, in-vector InVec2, scalar Scalar> Scalar dot(InVec1 v1, InVec2 v2, Scalar init); template<class ExecutionPolicy, in-vector InVec1, in-vector InVec2, scalar Scalar> Scalar dot(ExecutionPolicy&& exec, InVec1 v1, InVec2 v2, Scalar init); template<in-vector InVec1, in-vector InVec2> auto dot(InVec1 v1, InVec2 v2); template<class ExecutionPolicy, in-vector InVec1, in-vector InVec2> auto dot(ExecutionPolicy&& exec, InVec1 v1, InVec2 v2); template<in-vector InVec1, in-vector InVec2, scalar Scalar> Scalar dotc(InVec1 v1, InVec2 v2, Scalar init); template<class ExecutionPolicy, in-vector InVec1, in-vector InVec2, scalar Scalar> Scalar dotc(ExecutionPolicy&& exec, InVec1 v1, InVec2 v2, Scalar init); template<in-vector InVec1, in-vector InVec2> auto dotc(InVec1 v1, InVec2 v2); template<class ExecutionPolicy, in-vector InVec1, in-vector InVec2> auto dotc(ExecutionPolicy&& exec, InVec1 v1, InVec2 v2); / [linalg.algs.blas1.nrm2], Euclidean norm of a vector template<in-vector InVec, scalar Scalar> Scalar vector_two_norm(InVec v, Scalar init); template<class ExecutionPolicy, in-vector InVec, scalar Scalar> Scalar vector_two_norm(ExecutionPolicy&& exec, InVec v, Scalar init); template<in-vector InVec> auto vector_two_norm(InVec v); template<class ExecutionPolicy, in-vector InVec> auto vector_two_norm(ExecutionPolicy&& exec, InVec v); / [linalg.algs.blas1.asum], sum of absolute values of vector elements template<in-vector InVec, scalar Scalar> Scalar vector_abs_sum(InVec v, Scalar init); template<class ExecutionPolicy, in-vector InVec, scalar Scalar> Scalar vector_abs_sum(ExecutionPolicy&& exec, InVec v, Scalar init); template<in-vector InVec> auto vector_abs_sum(InVec v); template<class ExecutionPolicy, in-vector InVec> auto vector_abs_sum(ExecutionPolicy&& exec, InVec v); / [linalg.algs.blas1.iamax], index of maximum absolute value of vector elements template<in-vector InVec> typename InVec::extents_type vector_idx_abs_max(InVec v); template<class ExecutionPolicy, in-vector InVec> typename InVec::extents_type vector_idx_abs_max(ExecutionPolicy&& exec, InVec v); / [linalg.algs.blas1.matfrobnorm], Frobenius norm of a matrix template<in-matrix InMat, scalar Scalar> Scalar matrix_frob_norm(InMat A, Scalar init); template<class ExecutionPolicy, in-matrix InMat, scalar Scalar> Scalar matrix_frob_norm(ExecutionPolicy&& exec, InMat A, Scalar init); template<in-matrix InMat> auto matrix_frob_norm(InMat A); template<class ExecutionPolicy, in-matrix InMat> auto matrix_frob_norm(ExecutionPolicy&& exec, InMat A); / [linalg.algs.blas1.matonenorm], one norm of a matrix template<in-matrix InMat, scalar Scalar> Scalar matrix_one_norm(InMat A, Scalar init); template<class ExecutionPolicy, in-matrix InMat, scalar Scalar> Scalar matrix_one_norm(ExecutionPolicy&& exec, InMat A, Scalar init); template<in-matrix InMat> auto matrix_one_norm(InMat A); template<class ExecutionPolicy, in-matrix InMat> auto matrix_one_norm(ExecutionPolicy&& exec, InMat A); / [linalg.algs.blas1.matinfnorm], infinity norm of a matrix template<in-matrix InMat, scalar Scalar> Scalar matrix_inf_norm(InMat A, Scalar init); template<class ExecutionPolicy, in-matrix InMat, scalar Scalar> Scalar matrix_inf_norm(ExecutionPolicy&& exec, InMat A, Scalar init); template<in-matrix InMat> auto matrix_inf_norm(InMat A); template<class ExecutionPolicy, in-matrix InMat> auto matrix_inf_norm(ExecutionPolicy&& exec, InMat A); / [linalg.algs.blas2], BLAS 2 algorithms / [linalg.algs.blas2.gemv], general matrix-vector product template<in-matrix InMat, in-vector InVec, out-vector OutVec> void matrix_vector_product(InMat A, InVec x, OutVec y); template<class ExecutionPolicy, in-matrix InMat, in-vector InVec, out-vector OutVec> void matrix_vector_product(ExecutionPolicy&& exec, InMat A, InVec x, OutVec y); template<in-matrix InMat, in-vector InVec1, in-vector InVec2, out-vector OutVec> void matrix_vector_product(InMat A, InVec1 x, InVec2 y, OutVec z); template<class ExecutionPolicy, in-matrix InMat, in-vector InVec1, in-vector InVec2, out-vector OutVec> void matrix_vector_product(ExecutionPolicy&& exec, InMat A, InVec1 x, InVec2 y, OutVec z); / [linalg.algs.blas2.symv], symmetric matrix-vector product template<in-matrix InMat, class Triangle, in-vector InVec, out-vector OutVec> void symmetric_matrix_vector_product(InMat A, Triangle t, InVec x, OutVec y); template<class ExecutionPolicy, in-matrix InMat, class Triangle, in-vector InVec, out-vector OutVec> void symmetric_matrix_vector_product(ExecutionPolicy&& exec, InMat A, Triangle t, InVec x, OutVec y); template<in-matrix InMat, class Triangle, in-vector InVec1, in-vector InVec2, out-vector OutVec> void symmetric_matrix_vector_product(InMat A, Triangle t, InVec1 x, InVec2 y, OutVec z); template<class ExecutionPolicy, in-matrix InMat, class Triangle, in-vector InVec1, in-vector InVec2, out-vector OutVec> void symmetric_matrix_vector_product(ExecutionPolicy&& exec, InMat A, Triangle t, InVec1 x, InVec2 y, OutVec z); / [linalg.algs.blas2.hemv], Hermitian matrix-vector product template<in-matrix InMat, class Triangle, in-vector InVec, out-vector OutVec> void hermitian_matrix_vector_product(InMat A, Triangle t, InVec x, OutVec y); template<class ExecutionPolicy, in-matrix InMat, class Triangle, in-vector InVec, out-vector OutVec> void hermitian_matrix_vector_product(ExecutionPolicy&& exec, InMat A, Triangle t, InVec x, OutVec y); template<in-matrix InMat, class Triangle, in-vector InVec1, in-vector InVec2, out-vector OutVec> void hermitian_matrix_vector_product(InMat A, Triangle t, InVec1 x, InVec2 y, OutVec z); template<class ExecutionPolicy, in-matrix InMat, class Triangle, in-vector InVec1, in-vector InVec2, out-vector OutVec> void hermitian_matrix_vector_product(ExecutionPolicy&& exec, InMat A, Triangle t, InVec1 x, InVec2 y, OutVec z); / [linalg.algs.blas2.trmv], triangular matrix-vector product / Overwriting triangular matrix-vector product template<in-matrix InMat, class Triangle, class DiagonalStorage, in-vector InVec, out-vector OutVec> void triangular_matrix_vector_product(InMat A, Triangle t, DiagonalStorage d, InVec x, OutVec y); template<class ExecutionPolicy, in-matrix InMat, class Triangle, class DiagonalStorage, in-vector InVec, out-vector OutVec> void triangular_matrix_vector_product(ExecutionPolicy&& exec, InMat A, Triangle t, DiagonalStorage d, InVec x, OutVec y); / In-place triangular matrix-vector product template<in-matrix InMat, class Triangle, class DiagonalStorage, inout-vector InOutVec> void triangular_matrix_vector_product(InMat A, Triangle t, DiagonalStorage d, InOutVec y); template<class ExecutionPolicy, in-matrix InMat, class Triangle, class DiagonalStorage, inout-vector InOutVec> void triangular_matrix_vector_product(ExecutionPolicy&& exec, InMat A, Triangle t, DiagonalStorage d, InOutVec y); / Updating triangular matrix-vector product template<in-matrix InMat, class Triangle, class DiagonalStorage, in-vector InVec1, in-vector InVec2, out-vector OutVec> void triangular_matrix_vector_product(InMat A, Triangle t, DiagonalStorage d, InVec1 x, InVec2 y, OutVec z); template<class ExecutionPolicy, in-matrix InMat, class Triangle, class DiagonalStorage, in-vector InVec1, in-vector InVec2, out-vector OutVec> void triangular_matrix_vector_product(ExecutionPolicy&& exec, InMat A, Triangle t, DiagonalStorage d, InVec1 x, InVec2 y, OutVec z); / [linalg.algs.blas2.trsv], solve a triangular linear system / Solve a triangular linear system, not in place template<in-matrix InMat, class Triangle, class DiagonalStorage, in-vector InVec, out-vector OutVec, class BinaryDivideOp> void triangular_matrix_vector_solve(InMat A, Triangle t, DiagonalStorage d, InVec b, OutVec x, BinaryDivideOp divide); template<class ExecutionPolicy, in-matrix InMat, class Triangle, class DiagonalStorage, in-vector InVec, out-vector OutVec, class BinaryDivideOp> void triangular_matrix_vector_solve(ExecutionPolicy&& exec, InMat A, Triangle t, DiagonalStorage d, InVec b, OutVec x, BinaryDivideOp divide); template<in-matrix InMat, class Triangle, class DiagonalStorage, in-vector InVec, out-vector OutVec> void triangular_matrix_vector_solve(InMat A, Triangle t, DiagonalStorage d, InVec b, OutVec x); template<class ExecutionPolicy, in-matrix InMat, class Triangle, class DiagonalStorage, in-vector InVec, out-vector OutVec> void triangular_matrix_vector_solve(ExecutionPolicy&& exec, InMat A, Triangle t, DiagonalStorage d, InVec b, OutVec x); / Solve a triangular linear system, in place template<in-matrix InMat, class Triangle, class DiagonalStorage, inout-vector InOutVec, class BinaryDivideOp> void triangular_matrix_vector_solve(InMat A, Triangle t, DiagonalStorage d, InOutVec b, BinaryDivideOp divide); template<class ExecutionPolicy, in-matrix InMat, class Triangle, class DiagonalStorage, inout-vector InOutVec, class BinaryDivideOp> void triangular_matrix_vector_solve(ExecutionPolicy&& exec, InMat A, Triangle t, DiagonalStorage d, InOutVec b, BinaryDivideOp divide); template<in-matrix InMat, class Triangle, class DiagonalStorage, inout-vector InOutVec> void triangular_matrix_vector_solve(InMat A, Triangle t, DiagonalStorage d, InOutVec b); template<class ExecutionPolicy, in-matrix InMat, class Triangle, class DiagonalStorage, inout-vector InOutVec> void triangular_matrix_vector_solve(ExecutionPolicy&& exec, InMat A, Triangle t, DiagonalStorage d, InOutVec b); / [linalg.algs.blas2.rank1], nonsymmetric rank-1 matrix update / overwriting nonsymmetric rank-1 matrix update template<in-vector InVec1, in-vector InVec2, out-matrix OutMat> void matrix_rank_1_update(InVec1 x, InVec2 y, OutMat A); template<class ExecutionPolicy, in-vector InVec1, in-vector InVec2, out-matrix OutMat> void matrix_rank_1_update(ExecutionPolicy&& exec, InVec1 x, InVec2 y, OutMat A); template<in-vector InVec1, in-vector InVec2, out-matrix OutMat> void matrix_rank_1_update_c(InVec1 x, InVec2 y, OutMat A); template<class ExecutionPolicy, in-vector InVec1, in-vector InVec2, out-matrix OutMat> void matrix_rank_1_update_c(ExecutionPolicy&& exec, InVec1 x, InVec2 y, OutMat A); / updating nonsymmetric rank-1 matrix update template<in-vector InVec1, in-vector InVec2, in-matrix InMat, out-matrix OutMat> void matrix_rank_1_update(InVec1 x, InVec2 y, InMat E, OutMat A); template<class ExecutionPolicy, in-vector InVec1, in-vector InVec2, in-matrix InMat, out-matrix OutMat> void matrix_rank_1_update(ExecutionPolicy&& exec, InVec1 x, InVec2 y, InMat E, OutMat A); template<in-vector InVec1, in-vector InVec2, in-matrix InMat, out-matrix OutMat> void matrix_rank_1_update_c(InVec1 x, InVec2 y, InMat E, OutMat A); template<class ExecutionPolicy, in-vector InVec1, in-vector InVec2, in-matrix InMat, out-matrix OutMat> void matrix_rank_1_update_c(ExecutionPolicy&& exec, InVec1 x, InVec2 y, InMat E, OutMat A); / [linalg.algs.blas2.symherrank1], symmetric or Hermitian rank-1 matrix update / overwriting symmetric rank-1 matrix update template<scalar Scalar, in-vector InVec, possibly-packed-out-matrix OutMat, class Triangle> void symmetric_matrix_rank_1_update(Scalar alpha, InVec x, OutMat A, Triangle t); template<class ExecutionPolicy, scalar Scalar, in-vector InVec, possibly-packed-out-matrix OutMat, class Triangle> void symmetric_matrix_rank_1_update(ExecutionPolicy&& exec, Scalar alpha, InVec x, OutMat A, Triangle t); / overwriting Hermitian rank-1 matrix update template<scalar Scalar, in-vector InVec, possibly-packed-out-matrix OutMat, class Triangle> void hermitian_matrix_rank_1_update(Scalar alpha, InVec x, OutMat A, Triangle t); template<class ExecutionPolicy, scalar Scalar, in-vector InVec, possibly-packed-out-matrix OutMat, class Triangle> void hermitian_matrix_rank_1_update(ExecutionPolicy&& exec, Scalar alpha, InVec x, OutMat A, Triangle t); / updating symmetric rank-1 matrix update template<scalar Scalar, in-vector InVec, in-matrix InMat, possibly-packed-out-matrix OutMat, class Triangle> void symmetric_matrix_rank_1_update(Scalar alpha, InVec x, InMat E, OutMat A, Triangle t); template<class ExecutionPolicy, scalar Scalar, in-vector InVec, in-matrix InMat, possibly-packed-out-matrix OutMat, class Triangle> void symmetric_matrix_rank_1_update(ExecutionPolicy&& exec, Scalar alpha, InVec x, InMat E, OutMat A, Triangle t); / updating Hermitian rank-1 matrix update template<scalar Scalar, in-vector InVec, in-matrix InMat, possibly-packed-out-matrix OutMat, class Triangle> void hermitian_matrix_rank_1_update(Scalar alpha, InVec x, InMat E, OutMat A, Triangle t); template<class ExecutionPolicy, scalar Scalar, in-vector InVec, in-matrix InMat, possibly-packed-out-matrix OutMat, class Triangle> void hermitian_matrix_rank_1_update(ExecutionPolicy&& exec, Scalar alpha, InVec x, InMat E, OutMat A, Triangle t); / [linalg.algs.blas2.rank2], symmetric and Hermitian rank-2 matrix updates / overwriting symmetric rank-2 matrix update template<in-vector InVec1, in-vector InVec2, possibly-packed-out-matrix OutMat, class Triangle> void symmetric_matrix_rank_2_update(InVec1 x, InVec2 y, OutMat A, Triangle t); template<class ExecutionPolicy, in-vector InVec1, in-vector InVec2, possibly-packed-out-matrix OutMat, class Triangle> void symmetric_matrix_rank_2_update(ExecutionPolicy&& exec, InVec1 x, InVec2 y, OutMat A, Triangle t); / overwriting Hermitian rank-2 matrix update template<in-vector InVec1, in-vector InVec2, possibly-packed-out-matrix OutMat, class Triangle> void hermitian_matrix_rank_2_update(InVec1 x, InVec2 y, OutMat A, Triangle t); template<class ExecutionPolicy, in-vector InVec1, in-vector InVec2, possibly-packed-out-matrix OutMat, class Triangle> void hermitian_matrix_rank_2_update(ExecutionPolicy&& exec, InVec1 x, InVec2 y, OutMat A, Triangle t); / updating symmetric rank-2 matrix update template<in-vector InVec1, in-vector InVec2, in-matrix InMat, possibly-packed-out-matrix OutMat, class Triangle> void symmetric_matrix_rank_2_update(InVec1 x, InVec2 y, InMat E, OutMat A, Triangle t); template<class ExecutionPolicy, in-vector InVec1, in-vector InVec2, in-matrix InMat, possibly-packed-out-matrix OutMat, class Triangle> void symmetric_matrix_rank_2_update(ExecutionPolicy&& exec, InVec1 x, InVec2 y, InMat E, OutMat A, Triangle t); / updating Hermitian rank-2 matrix update template<in-vector InVec1, in-vector InVec2, in-matrix InMat, possibly-packed-out-matrix OutMat, class Triangle> void hermitian_matrix_rank_2_update(InVec1 x, InVec2 y, InMat E, OutMat A, Triangle t); template<class ExecutionPolicy, in-vector InVec1, in-vector InVec2, in-matrix InMat, possibly-packed-out-matrix OutMat, class Triangle> void hermitian_matrix_rank_2_update(ExecutionPolicy&& exec, InVec1 x, InVec2 y, InMat E, OutMat A, Triangle t); / [linalg.algs.blas3], BLAS 3 algorithms / [linalg.algs.blas3.gemm], general matrix-matrix product template<in-matrix InMat1, in-matrix InMat2, out-matrix OutMat> void matrix_product(InMat1 A, InMat2 B, OutMat C); template<class ExecutionPolicy, in-matrix InMat1, in-matrix InMat2, out-matrix OutMat> void matrix_product(ExecutionPolicy&& exec, InMat1 A, InMat2 B, OutMat C); template<in-matrix InMat1, in-matrix InMat2, in-matrix InMat3, out-matrix OutMat> void matrix_product(InMat1 A, InMat2 B, InMat3 E, OutMat C); template<class ExecutionPolicy, in-matrix InMat1, in-matrix InMat2, in-matrix InMat3, out-matrix OutMat> void matrix_product(ExecutionPolicy&& exec, InMat1 A, InMat2 B, InMat3 E, OutMat C); / [linalg.algs.blas3.xxmm], symmetric, Hermitian, and triangular matrix-matrix product template<in-matrix InMat1, class Triangle, in-matrix InMat2, out-matrix OutMat> void symmetric_matrix_product(InMat1 A, Triangle t, InMat2 B, OutMat C); template<class ExecutionPolicy, in-matrix InMat1, class Triangle, in-matrix InMat2, out-matrix OutMat> void symmetric_matrix_product(ExecutionPolicy&& exec, InMat1 A, Triangle t, InMat2 B, OutMat C); template<in-matrix InMat1, class Triangle, in-matrix InMat2, out-matrix OutMat> void hermitian_matrix_product(InMat1 A, Triangle t, InMat2 B, OutMat C); template<class ExecutionPolicy, in-matrix InMat1, class Triangle, in-matrix InMat2, out-matrix OutMat> void hermitian_matrix_product(ExecutionPolicy&& exec, InMat1 A, Triangle t, InMat2 B, OutMat C); template<in-matrix InMat1, class Triangle, class DiagonalStorage, in-matrix InMat2, out-matrix OutMat> void triangular_matrix_product(InMat1 A, Triangle t, DiagonalStorage d, InMat2 B, OutMat C); template<class ExecutionPolicy, in-matrix InMat1, class Triangle, class DiagonalStorage, in-matrix InMat2, out-matrix OutMat> void triangular_matrix_product(ExecutionPolicy&& exec, InMat1 A, Triangle t, DiagonalStorage d, InMat2 B, OutMat C); template<in-matrix InMat1, in-matrix InMat2, class Triangle, out-matrix OutMat> void symmetric_matrix_product(InMat1 A, InMat2 B, Triangle t, OutMat C); template<class ExecutionPolicy, in-matrix InMat1, in-matrix InMat2, class Triangle, out-matrix OutMat> void symmetric_matrix_product(ExecutionPolicy&& exec, InMat1 A, InMat2 B, Triangle t, OutMat C); template<in-matrix InMat1, in-matrix InMat2, class Triangle, out-matrix OutMat> void hermitian_matrix_product(InMat1 A, InMat2 B, Triangle t, OutMat C); template<class ExecutionPolicy, in-matrix InMat1, in-matrix InMat2, class Triangle, out-matrix OutMat> void hermitian_matrix_product(ExecutionPolicy&& exec, InMat1 A, InMat2 B, Triangle t, OutMat C); template<in-matrix InMat1, in-matrix InMat2, class Triangle, class DiagonalStorage, out-matrix OutMat> void triangular_matrix_product(InMat1 A, InMat2 B, Triangle t, DiagonalStorage d, OutMat C); template<class ExecutionPolicy, in-matrix InMat1, in-matrix InMat2, class Triangle, class DiagonalStorage, out-matrix OutMat> void triangular_matrix_product(ExecutionPolicy&& exec, InMat1 A, InMat2 B, Triangle t, DiagonalStorage d, OutMat C); template<in-matrix InMat1, class Triangle, in-matrix InMat2, in-matrix InMat3, out-matrix OutMat> void symmetric_matrix_product(InMat1 A, Triangle t, InMat2 B, InMat3 E, OutMat C); template<class ExecutionPolicy, in-matrix InMat1, class Triangle, in-matrix InMat2, in-matrix InMat3, out-matrix OutMat> void symmetric_matrix_product(ExecutionPolicy&& exec, InMat1 A, Triangle t, InMat2 B, InMat3 E, OutMat C); template<in-matrix InMat1, class Triangle, in-matrix InMat2, in-matrix InMat3, out-matrix OutMat> void hermitian_matrix_product(InMat1 A, Triangle t, InMat2 B, InMat3 E, OutMat C); template<class ExecutionPolicy, in-matrix InMat1, class Triangle, in-matrix InMat2, in-matrix InMat3, out-matrix OutMat> void hermitian_matrix_product(ExecutionPolicy&& exec, InMat1 A, Triangle t, InMat2 B, InMat3 E, OutMat C); template<in-matrix InMat1, class Triangle, class DiagonalStorage, in-matrix InMat2, in-matrix InMat3, out-matrix OutMat> void triangular_matrix_product(InMat1 A, Triangle t, DiagonalStorage d, InMat2 B, InMat3 E, OutMat C); template<class ExecutionPolicy, in-matrix InMat1, class Triangle, class DiagonalStorage, in-matrix InMat2, in-matrix InMat3, out-matrix OutMat> void triangular_matrix_product(ExecutionPolicy&& exec, InMat1 A, Triangle t, DiagonalStorage d, InMat2 B, InMat3 E, OutMat C); template<in-matrix InMat1, in-matrix InMat2, class Triangle, in-matrix InMat3, out-matrix OutMat> void symmetric_matrix_product(InMat1 A, InMat2 B, Triangle t, InMat3 E, OutMat C); template<class ExecutionPolicy, in-matrix InMat1, in-matrix InMat2, class Triangle, in-matrix InMat3, out-matrix OutMat> void symmetric_matrix_product(ExecutionPolicy&& exec, InMat1 A, InMat2 B, Triangle t, InMat3 E, OutMat C); template<in-matrix InMat1, in-matrix InMat2, class Triangle, in-matrix InMat3, out-matrix OutMat> void hermitian_matrix_product(InMat1 A, InMat2 B, Triangle t, InMat3 E, OutMat C); template<class ExecutionPolicy, in-matrix InMat1, in-matrix InMat2, class Triangle, in-matrix InMat3, out-matrix OutMat> void hermitian_matrix_product(ExecutionPolicy&& exec, InMat1 A, InMat2 B, Triangle t, InMat3 E, OutMat C); template<in-matrix InMat1, in-matrix InMat2, class Triangle, class DiagonalStorage, in-matrix InMat3, out-matrix OutMat> void triangular_matrix_product(InMat1 A, InMat2 B, Triangle t, DiagonalStorage d, InMat3 E, OutMat C); template<class ExecutionPolicy, in-matrix InMat1, in-matrix InMat2, class Triangle, class DiagonalStorage, in-matrix InMat3, out-matrix OutMat> void triangular_matrix_product(ExecutionPolicy&& exec, InMat1 A, InMat2 B, Triangle t, DiagonalStorage d, InMat3 E, OutMat C); / [linalg.algs.blas3.trmm], in-place triangular matrix-matrix product template<in-matrix InMat, class Triangle, class DiagonalStorage, inout-matrix InOutMat> void triangular_matrix_left_product(InMat A, Triangle t, DiagonalStorage d, InOutMat C); template<class ExecutionPolicy, in-matrix InMat, class Triangle, class DiagonalStorage, inout-matrix InOutMat> void triangular_matrix_left_product(ExecutionPolicy&& exec, InMat A, Triangle t, DiagonalStorage d, InOutMat C); template<in-matrix InMat, class Triangle, class DiagonalStorage, inout-matrix InOutMat> void triangular_matrix_right_product(InMat A, Triangle t, DiagonalStorage d, InOutMat C); template<class ExecutionPolicy, in-matrix InMat, class Triangle, class DiagonalStorage, inout-matrix InOutMat> void triangular_matrix_right_product(ExecutionPolicy&& exec, InMat A, Triangle t, DiagonalStorage d, InOutMat C); / [linalg.algs.blas3.rankk], rank-k update of a symmetric or Hermitian matrix / overwriting rank-k symmetric matrix update template<scalar Scalar, in-matrix InMat, possibly-packed-out-matrix OutMat, class Triangle> void symmetric_matrix_rank_k_update(Scalar alpha, InMat A, OutMat C, Triangle t); template<class ExecutionPolicy, scalar Scalar, in-matrix InMat, possibly-packed-out-matrix OutMat, class Triangle> void symmetric_matrix_rank_k_update(ExecutionPolicy&& exec, Scalar alpha, InMat A, OutMat C, Triangle t); / overwriting rank-k Hermitian matrix update template<scalar Scalar, in-matrix InMat, possibly-packed-out-matrix OutMat, class Triangle> void hermitian_matrix_rank_k_update(Scalar alpha, InMat A, OutMat C, Triangle t); template<class ExecutionPolicy, scalar Scalar, in-matrix InMat, possibly-packed-out-matrix OutMat, class Triangle> void hermitian_matrix_rank_k_update(ExecutionPolicy&& exec, Scalar alpha, InMat A, OutMat C, Triangle t); / updating rank-k symmetric matrix update template<scalar Scalar, in-matrix InMat1, in-matrix InMat2, possibly-packed-out-matrix OutMat, class Triangle> void symmetric_matrix_rank_k_update(Scalar alpha, InMat1 A, InMat2 E, OutMat C, Triangle t); template<class ExecutionPolicy, scalar Scalar, in-matrix InMat1, in-matrix InMat2, possibly-packed-out-matrix OutMat, class Triangle> void symmetric_matrix_rank_k_update(ExecutionPolicy&& exec, Scalar alpha, InMat1 A, InMat2 E, OutMat C, Triangle t); / updating rank-k Hermitian matrix update template<scalar Scalar, in-matrix InMat1, in-matrix InMat2, possibly-packed-out-matrix OutMat, class Triangle> void hermitian_matrix_rank_k_update(Scalar alpha, InMat1 A, InMat2 E, OutMat C, Triangle t); template<class ExecutionPolicy, scalar Scalar, in-matrix InMat1, in-matrix InMat2, possibly-packed-out-matrix OutMat, class Triangle> void hermitian_matrix_rank_k_update(ExecutionPolicy&& exec, Scalar alpha, InMat1 A, InMat2 E, OutMat C, Triangle t); / [linalg.algs.blas3.rank2k], rank-2k update of a symmetric or Hermitian matrix / overwriting rank-2k symmetric matrix update template<in-matrix InMat1, in-matrix InMat2, possibly-packed-out-matrix OutMat, class Triangle> void symmetric_matrix_rank_2k_update(InMat1 A, InMat2 B, OutMat C, Triangle t); template<class ExecutionPolicy, in-matrix InMat1, in-matrix InMat2, possibly-packed-out-matrix OutMat, class Triangle> void symmetric_matrix_rank_2k_update(ExecutionPolicy&& exec, InMat1 A, InMat2 B, OutMat C, Triangle t); / overwriting rank-2k Hermitian matrix update template<in-matrix InMat1, in-matrix InMat2, possibly-packed-out-matrix OutMat, class Triangle> void hermitian_matrix_rank_2k_update(InMat1 A, InMat2 B, OutMat C, Triangle t); template<class ExecutionPolicy, in-matrix InMat1, in-matrix InMat2, possibly-packed-out-matrix OutMat, class Triangle> void hermitian_matrix_rank_2k_update(ExecutionPolicy&& exec, InMat1 A, InMat2 B, OutMat C, Triangle t); / updating symmetric rank-2k matrix update template<in-matrix InMat1, in-matrix InMat2, in-matrix InMat3, possibly-packed-out-matrix OutMat, class Triangle> void symmetric_matrix_rank_2k_update(InMat1 A, InMat2 B, InMat3 E, OutMat C, Triangle t); template<class ExecutionPolicy, in-matrix InMat1, in-matrix InMat2, in-matrix InMat3, possibly-packed-out-matrix OutMat, class Triangle> void symmetric_matrix_rank_2k_update(ExecutionPolicy&& exec, InMat1 A, InMat2 B, InMat3 E, OutMat C, Triangle t); / updating Hermitian rank-2k matrix update template<in-matrix InMat1, in-matrix InMat2, in-matrix InMat3, possibly-packed-out-matrix OutMat, class Triangle> void hermitian_matrix_rank_2k_update(InMat1 A, InMat2 B, InMat3 E, OutMat C, Triangle t); template<class ExecutionPolicy, in-matrix InMat1, in-matrix InMat2, in-matrix InMat3, possibly-packed-out-matrix OutMat, class Triangle> void hermitian_matrix_rank_2k_update(ExecutionPolicy&& exec, InMat1 A, InMat2 B, InMat3 E, OutMat C, Triangle t); / [linalg.algs.blas3.trsm], solve multiple triangular linear systems / solve multiple triangular systems on the left, not-in-place template<in-matrix InMat1, class Triangle, class DiagonalStorage, in-matrix InMat2, out-matrix OutMat, class BinaryDivideOp> void triangular_matrix_matrix_left_solve(InMat1 A, Triangle t, DiagonalStorage d, InMat2 B, OutMat X, BinaryDivideOp divide); template<class ExecutionPolicy, in-matrix InMat1, class Triangle, class DiagonalStorage, in-matrix InMat2, out-matrix OutMat, class BinaryDivideOp> void triangular_matrix_matrix_left_solve(ExecutionPolicy&& exec, InMat1 A, Triangle t, DiagonalStorage d, InMat2 B, OutMat X, BinaryDivideOp divide); template<in-matrix InMat1, class Triangle, class DiagonalStorage, in-matrix InMat2, out-matrix OutMat> void triangular_matrix_matrix_left_solve(InMat1 A, Triangle t, DiagonalStorage d, InMat2 B, OutMat X); template<class ExecutionPolicy, in-matrix InMat1, class Triangle, class DiagonalStorage, in-matrix InMat2, out-matrix OutMat> void triangular_matrix_matrix_left_solve(ExecutionPolicy&& exec, InMat1 A, Triangle t, DiagonalStorage d, InMat2 B, OutMat X); / solve multiple triangular systems on the right, not-in-place template<in-matrix InMat1, class Triangle, class DiagonalStorage, in-matrix InMat2, out-matrix OutMat, class BinaryDivideOp> void triangular_matrix_matrix_right_solve(InMat1 A, Triangle t, DiagonalStorage d, InMat2 B, OutMat X, BinaryDivideOp divide); template<class ExecutionPolicy, in-matrix InMat1, class Triangle, class DiagonalStorage, in-matrix InMat2, out-matrix OutMat, class BinaryDivideOp> void triangular_matrix_matrix_right_solve(ExecutionPolicy&& exec, InMat1 A, Triangle t, DiagonalStorage d, InMat2 B, OutMat X, BinaryDivideOp divide); template<in-matrix InMat1, class Triangle, class DiagonalStorage, in-matrix InMat2, out-matrix OutMat> void triangular_matrix_matrix_right_solve(InMat1 A, Triangle t, DiagonalStorage d, InMat2 B, OutMat X); template<class ExecutionPolicy, in-matrix InMat1, class Triangle, class DiagonalStorage, in-matrix InMat2, out-matrix OutMat> void triangular_matrix_matrix_right_solve(ExecutionPolicy&& exec, InMat1 A, Triangle t, DiagonalStorage d, InMat2 B, OutMat X); / solve multiple triangular systems on the left, in-place template<in-matrix InMat, class Triangle, class DiagonalStorage, inout-matrix InOutMat, class BinaryDivideOp> void triangular_matrix_matrix_left_solve(InMat A, Triangle t, DiagonalStorage d, InOutMat B, BinaryDivideOp divide); template<class ExecutionPolicy, in-matrix InMat, class Triangle, class DiagonalStorage, inout-matrix InOutMat, class BinaryDivideOp> void triangular_matrix_matrix_left_solve(ExecutionPolicy&& exec, InMat A, Triangle t, DiagonalStorage d, InOutMat B, BinaryDivideOp divide); template<in-matrix InMat, class Triangle, class DiagonalStorage, inout-matrix InOutMat> void triangular_matrix_matrix_left_solve(InMat A, Triangle t, DiagonalStorage d, InOutMat B); template<class ExecutionPolicy, in-matrix InMat, class Triangle, class DiagonalStorage, inout-matrix InOutMat> void triangular_matrix_matrix_left_solve(ExecutionPolicy&& exec, InMat A, Triangle t, DiagonalStorage d, InOutMat B); / solve multiple triangular systems on the right, in-place template<in-matrix InMat, class Triangle, class DiagonalStorage, inout-matrix InOutMat, class BinaryDivideOp> void triangular_matrix_matrix_right_solve(InMat A, Triangle t, DiagonalStorage d, InOutMat B, BinaryDivideOp divide); template<class ExecutionPolicy, in-matrix InMat, class Triangle, class DiagonalStorage, inout-matrix InOutMat, class BinaryDivideOp> void triangular_matrix_matrix_right_solve(ExecutionPolicy&& exec, InMat A, Triangle t, DiagonalStorage d, InOutMat B, BinaryDivideOp divide); template<in-matrix InMat, class Triangle, class DiagonalStorage, inout-matrix InOutMat> void triangular_matrix_matrix_right_solve(InMat A, Triangle t, DiagonalStorage d, InOutMat B); template<class ExecutionPolicy, in-matrix InMat, class Triangle, class DiagonalStorage, inout-matrix InOutMat> void triangular_matrix_matrix_right_solve(ExecutionPolicy&& exec, InMat A, Triangle t, DiagonalStorage d, InOutMat B); }
1
#
For the effects of all functions in [linalg], when the effects are described as “computes
2
#
Some of the functions and types in [linalg] distinguish between the “rows” and the “columns” of a matrix.
For a matrix A and a multidimensional index i, j in A.extents(),
  • (2.1)
    row i of A is the set of elements A[i, k1] for all k1 such that i, k1 is in A.extents(); and
  • (2.2)
    column j of A is the set of elements A[k0, j] for all k0 such that k0, j is in A.extents().
3
#
Some of the functions in [linalg] distinguish between the “upper triangle,” “lower triangle,” and “diagonal” of a matrix.
  • (3.1)
    The diagonal is the set of all elements of A accessed by A[i,i] for 0  ≤  i < min(A.extent(0), A.extent(1)).
  • (3.2)
    The upper triangle of a matrix A is the set of all elements of A accessed by A[i,j] with i  ≤  j.
    It includes the diagonal.
  • (3.3)
    The lower triangle of A is the set of all elements of A accessed by A[i,j] with i  ≥  j.
    It includes the diagonal.
4
#
For any function F that takes a parameter named t, t applies to accesses done through the parameter preceding t in the parameter list of F.
Let m be such an access-modified function parameter.
F will only access the triangle of m specified by t.
For accesses of diagonal elements m[i, i], F will use the value real-if-needed(m[i, i]) if the name of F starts with hermitian.
For accesses m[i, j] outside the triangle specified by t, F will use the value
  • (4.1)
    conj-if-needed(m[j, i]) if the name of F starts with hermitian,
  • (4.2)
    m[j, i] if the name of F starts with symmetric, or
  • (4.3)
    the additive identity if the name of F starts with triangular.
[Example 1: 
Small vector product accessing only specified triangle.
It would not be a precondition violation for the non-accessed matrix element to be non-zero.
template<class Triangle> void triangular_matrix_vector_2x2_product( mdspan<const float, extents<int, 2> m, Triangle t, mdspan<const float, extents<int, 2> x, mdspan<float, extents<int, 2> y) { static_assert(is_same_v<Triangle, lower_triangle_t> || is_same_v<Triangle, upper_triangle_t>); if constexpr (is_same_v<Triangle, lower_triangle_t>) { y[0] = m[0,0] * x[0]; / + 0 * x[1] y[1] = m[1,0] * x[0] + m[1,1] * x[1]; } else { / upper_triangle_t y[0] = m[0,0] * x[0] + m[0,1] * x[1]; y[1] = /* 0 * x[0] + */ m[1,1] * x[1]; } } — end example]
5
#
For any function F that takes a parameter named d, d applies to accesses done through the previous-of-the-previous parameter of d in the parameter list of F.
Let m be such an access-modified function parameter.
If d specifies that an implicit unit diagonal is to be assumed, then
  • (5.1)
    F will not access the diagonal of m; and
  • (5.2)
    the algorithm will interpret m as if it has a unit diagonal, that is, a diagonal each of whose elements behaves as a two-sided multiplicative identity (even if m's value type does not have a two-sided multiplicative identity).
Otherwise, if d specifies that an explicit diagonal is to be assumed, then F will access the diagonal of m.
6
#
Within all the functions in [linalg], any calls to abs, conj, imag, and real are unqualified.
7
#
Two mdspan objects x and y alias each other, if they have the same extents e, and for every pack of integers i which is a multidimensional index in e, x[i..] and y[i..] refer to the same element.
[Note 1: 
This means that x and y view the same elements in the same order.
— end note]
8
#
Two mdspan objects x and y overlap each other, if for some pack of integers i that is a multidimensional index in x.extents(), there exists a pack of integers j that is a multidimensional index in y.extents(), such that x[i..] and y[j..] refer to the same element.
[Note 2: 
Aliasing is a special case of overlapping.
If x and y do not overlap, then they also do not alias each other.
— end note]

29.9.4 Requirements [linalg.reqs]

29.9.4.1 Linear algebra value types [linalg.reqs.val]

1
#
Throughout [linalg], the following types are linear algebra value types:
  • (1.1)
    the value_type type alias of any input or output mdspan parameter(s) of any function in [linalg]; and
  • (1.2)
    the Scalar template parameter (if any) of any function or class in [linalg].
2
#
A value-initialized object of linear algebra value type shall act as the additive identity.

29.9.4.2 Algorithm and class requirements [linalg.reqs.alg]

1
#
[linalg.reqs.alg] lists common requirements for all algorithms and classes in [linalg].
2
#
All of the following statements presume that the algorithm's asymptotic complexity requirements, if any, are satisfied.
  • (2.1)
    The function may make arbitrarily many objects of any linear algebra value type, value-initializing or direct-initializing them with any existing object of that type.
  • (2.2)
    The triangular solve algorithms in [linalg.algs.blas2.trsv], [linalg.algs.blas3.trmm], [linalg.algs.blas3.trsm], and [linalg.algs.blas3.inplacetrsm] either have a BinaryDivideOp template parameter (see [linalg.algs.reqs]) and a binary function object parameter divide of that type, or they have effects equivalent to invoking such an algorithm.
    Triangular solve algorithms interpret divide(a, b) as a times the multiplicative inverse of b.
    Each triangular solve algorithm uses a sequence of evaluations of *, *=, divide, unary +, binary +, +=, unary -, binary -, -=, and = operators that would produce the result specified by the algorithm's Effects and Remarks when operating on elements of a field with noncommutative multiplication.
    It is a precondition of the algorithm that any addend, any subtrahend, any partial sum of addends in any order (treating any difference as a sum with the second term negated), any factor, any partial product of factors respecting their order, any numerator (first argument of divide), any denominator (second argument of divide), and any assignment is a well-formed expression.
  • (2.3)
    Each function in [linalg.algs.blas1], [linalg.algs.blas2], and [linalg.algs.blas3] that is not a triangular solve algorithm will use a sequence of evaluations of *, *=, +, +=, and = operators that would produce the result specified by the algorithm's Effects and Remarks when operating on elements of a semiring with noncommutative multiplication.
    It is a precondition of the algorithm that any addend, any partial sum of addends in any order, any factor, any partial product of factors respecting their order, and any assignment is a well-formed expression.
  • (2.4)
    If the function has an output mdspan, then all addends, subtrahends (for the triangular solve algorithms), or results of the divide parameter on intermediate terms (if the function takes a divide parameter) are assignable and convertible to the output mdspan's value_type.
  • (2.5)
    The function may reorder addends and partial sums arbitrarily.
    [Note 1: 
    Factors in each product are not reordered; multiplication is not necessarily commutative.
    — end note]
[Note 2: 
The above requirements do not prohibit implementation approaches and optimization techniques which are not user-observable.
In particular, if for all input and output arguments the value_type is a floating-point type, implementers are free to leverage approximations, use arithmetic operations not explicitly listed above, and compute floating-point sums in any way that improves their accuracy.
— end note]
3
#
[Note 3: 
For all functions in [linalg], suppose that all input and output mdspan have as value_type a floating-point type, and any Scalar template argument has a floating-point type.
Then, functions can do all of the following:
  • (3.1)
    compute floating-point sums in any way that improves their accuracy for arbitrary input;
  • (3.2)
    perform additional arithmetic operations (other than those specified by the function's wording and [linalg.reqs.alg]) in order to improve performance or accuracy; and
  • (3.3)
    use approximations (that might not be exact even if computing with real numbers), instead of computations that would be exact if it were possible to compute without rounding error;
as long as
  • (3.4)
    the function satisfies the complexity requirements; and
  • (3.5)
    the function is logarithmically stable, as defined in Demmel 2007[bib].
    Strassen's algorithm for matrix-matrix multiply is an example of a logarithmically stable algorithm.
— end note]

29.9.5 Tag classes [linalg.tags]

29.9.5.1 Storage order tags [linalg.tags.order]

1
#
The storage order tags describe the order of elements in an mdspan with layout_blas_packed ([linalg.layout.packed]) layout.
🔗
struct column_major_t { explicit column_major_t() = default; }; inline constexpr column_major_t column_major{}; struct row_major_t { explicit row_major_t() = default; }; inline constexpr row_major_t row_major{};
2
#
column_major_t indicates a column-major order, and row_major_t indicates a row-major order.
🔗
struct upper_triangle_t { explicit upper_triangle_t() = default; }; inline constexpr upper_triangle_t upper_triangle{}; struct lower_triangle_t { explicit lower_triangle_t() = default; }; inline constexpr lower_triangle_t lower_triangle{};
1
#
These tag classes specify whether algorithms and other users of a matrix (represented as an mdspan) access the upper triangle (upper_triangle_t) or lower triangle (lower_triangle_t) of the matrix (see also [linalg.general]).
This is also subject to the restrictions of implicit_unit_diagonal_t if that tag is also used as a function argument; see below.
🔗
struct implicit_unit_diagonal_t { explicit implicit_unit_diagonal_t() = default; }; inline constexpr implicit_unit_diagonal_t implicit_unit_diagonal{}; struct explicit_diagonal_t { explicit explicit_diagonal_t() = default; }; inline constexpr explicit_diagonal_t explicit_diagonal{};
1
#
These tag classes specify whether algorithms access the matrix's diagonal entries, and if not, then how algorithms interpret the matrix's implicitly represented diagonal values.
2
#
The implicit_unit_diagonal_t tag indicates that an implicit unit diagonal is to be assumed ([linalg.general]).
3
#
The explicit_diagonal_t tag indicates that an explicit diagonal is used ([linalg.general]).

29.9.6 Layouts for packed matrix types [linalg.layout.packed]

1
#
layout_blas_packed is an mdspan layout mapping policy that represents a square matrix that stores only the entries in one triangle, in a packed contiguous format.
Its Triangle template parameter determines whether an mdspan with this layout stores the upper or lower triangle of the matrix.
Its StorageOrder template parameter determines whether the layout packs the matrix's elements in column-major or row-major order.
2
#
A StorageOrder of column_major_t indicates column-major ordering.
This packs matrix elements starting with the leftmost (least column index) column, and proceeding column by column, from the top entry (least row index).
3
#
A StorageOrder of row_major_t indicates row-major ordering.
This packs matrix elements starting with the topmost (least row index) row, and proceeding row by row, from the leftmost (least column index) entry.
4
#
[Note 1: 
layout_blas_packed describes the data layout used by the BLAS' Symmetric Packed (SP), Hermitian Packed (HP), and Triangular Packed (TP) matrix types.
— end note]
namespace std::linalg { template<class Triangle, class StorageOrder> class layout_blas_packed { public: using triangle_type = Triangle; using storage_order_type = StorageOrder; template<class Extents> struct mapping { public: using extents_type = Extents; using index_type = extents_type::index_type; using size_type = extents_type::size_type; using rank_type = extents_type::rank_type; using layout_type = layout_blas_packed; / [linalg.layout.packed.cons], constructors constexpr mapping() noexcept = default; constexpr mapping(const mapping&) noexcept = default; constexpr mapping(const extents_type&) noexcept; template<class OtherExtents> constexpr explicit(!is_convertible_v<OtherExtents, extents_type>) mapping(const mapping<OtherExtents>& other) noexcept; constexpr mapping& operator=(const mapping&) noexcept = default; / [linalg.layout.packed.obs], observers constexpr const extents_type& extents() const noexcept { return extents_; } constexpr index_type required_span_size() const noexcept; template<class Index0, class Index1> constexpr index_type operator() (Index0 ind0, Index1 ind1) const noexcept; static constexpr bool is_always_unique() noexcept { return (extents_type::static_extent(0) != dynamic_extent && extents_type::static_extent(0) < 2) || (extents_type::static_extent(1) != dynamic_extent && extents_type::static_extent(1) < 2); } static constexpr bool is_always_exhaustive() noexcept { return true; } static constexpr bool is_always_strided() noexcept { return is_always_unique(); } constexpr bool is_unique() const noexcept { return extents_.extent(0) < 2; } constexpr bool is_exhaustive() const noexcept { return true; } constexpr bool is_strided() const noexcept { return extents_.extent(0) < 2; } constexpr index_type stride(rank_type) const noexcept; template<class OtherExtents> friend constexpr bool operator=(const mapping&, const mapping<OtherExtents>&) noexcept; private: extents_type extents_{}; / exposition only }; }; }
5
#
Mandates:
  • (5.1)
    Triangle is either upper_triangle_t or lower_triangle_t,
  • (5.2)
    StorageOrder is either column_major_t or row_major_t,
  • (5.3)
    Extents is a specialization of std​::​extents,
  • (5.4)
    Extents​::​rank() equals 2,
  • (5.5)
    one of extents_type::static_extent(0) == dynamic_extent, extents_type::static_extent(1) == dynamic_extent, or extents_type::static_extent(0) == extents_type::static_extent(1) is true, and
  • (5.6)
    if Extents​::​rank_dynamic() == 0 is true, let
6
#
layout_blas_packed<T, SO>​::​mapping<E> is a trivially copyable type that models regular for each T, SO, and E.
🔗
constexpr mapping(const extents_type& e) noexcept;
1
#
Preconditions:
2
#
Effects: Direct-non-list-initializes extents_ with e.
🔗
template<class OtherExtents> explicit(!is_convertible_v<OtherExtents, extents_type>) constexpr mapping(const mapping<OtherExtents>& other) noexcept;
3
#
Preconditions: Let N be other.extents().extent(0).
Then,
5
#
Effects: Direct-non-list-initializes extents_ with other.extents().
🔗
constexpr index_type required_span_size() const noexcept;
1
#
Returns: extents_.extent(0) * (extents_.extent(0) + 1)/2.
[Note 1: 
For example, a 5 x 5 packed matrix only stores 15 matrix elements.
— end note]
🔗
template<class Index0, class Index1> constexpr index_type operator() (Index0 ind0, Index1 ind1) const noexcept;
2
#
Let i be extents_type​::​index-cast(ind0), and let j be extents_type​::​index-cast(ind1).
4
#
Preconditions: i, j is a multidimensional index in extents_ ([mdspan.overview]).
5
#
Returns: Let N be extents_.extent(0).
Then
  • (5.1)
    (*this)(j, i) if i > j is true; otherwise
  • (5.2)
    i + j * (j + 1)/2 if is_same_v<StorageOrder, column_major_t> && is_same_v<Triangle, upper_triangle_t> is true or is_same_v<StorageOrder, row_major_t> && is_same_v<Triangle, lower_triangle_t> is true; otherwise
  • (5.3)
    j + N * i - i * (i + 1)/2.
🔗
constexpr index_type stride(rank_type r) const noexcept;
6
#
Returns: 1.
🔗
template<class OtherExtents> friend constexpr bool operator=(const mapping& x, const mapping<OtherExtents>& y) noexcept;
8
#
The name abs-if-needed denotes an exposition-only function object.
The expression abs-if-needed(E) for a subexpression E whose type is T is expression-equivalent to:
  • (1.1)
    E if T is an unsigned integer;
  • (1.2)
    otherwise, std​::​abs(E) if T is an arithmetic type,
  • (1.3)
    otherwise, abs(E), if that expression is valid, with overload resolution performed in a context that includes the declaration template<class U> U abs(U) = delete;
    If the function selected by overload resolution does not return the absolute value of its input, the program is ill-formed, no diagnostic required.
1
#
The name conj-if-needed denotes an exposition-only function object.
The expression conj-if-needed(E) for a subexpression E whose type is T is expression-equivalent to:
  • (1.1)
    conj(E), if T is not an arithmetic type and the expression conj(E) is valid, with overload resolution performed in a context that includes the declaration template<class U> U conj(const U&) = delete;
    If the function selected by overload resolution does not return the complex conjugate of its input, the program is ill-formed, no diagnostic required;
  • (1.2)
    otherwise, E.
1
#
The name real-if-needed denotes an exposition-only function object.
The expression real-if-needed(E) for a subexpression E whose type is T is expression-equivalent to:
  • (1.1)
    real(E), if T is not an arithmetic type and the expression real(E) is valid, with overload resolution performed in a context that includes the declaration template<class U> U real(const U&) = delete;
    If the function selected by overload resolution does not return the real part of its input, the program is ill-formed, no diagnostic required;
  • (1.2)
    otherwise, E.
1
#
The name imag-if-needed denotes an exposition-only function object.
The expression imag-if-needed(E) for a subexpression E whose type is T is expression-equivalent to:
  • (1.1)
    imag(E), if T is not an arithmetic type and the expression imag(E) is valid, with overload resolution performed in a context that includes the declaration template<class U> U imag(const U&) = delete;
    If the function selected by overload resolution does not return the imaginary part of its input, the program is ill-formed, no diagnostic required;
  • (1.2)
    otherwise, ((void)E, T{}).
1
#
The exposition-only concepts defined in this section constrain the algorithms in [linalg].
template<class T> constexpr bool is-mdspan = false; template<class ElementType, class Extents, class Layout, class Accessor> constexpr bool is-mdspan<mdspan<ElementType, Extents, Layout, Accessor>> = true; template<class T> concept in-vector = is-mdspan<T> && T::rank() == 1; template<class T> concept out-vector = is-mdspan<T> && T::rank() == 1 && is_assignable_v<typename T::reference, typename T::element_type> && T::is_always_unique(); template<class T> concept inout-vector = is-mdspan<T> && T::rank() == 1 && is_assignable_v<typename T::reference, typename T::element_type> && T::is_always_unique(); template<class T> concept in-matrix = is-mdspan<T> && T::rank() == 2; template<class T> concept out-matrix = is-mdspan<T> && T::rank() == 2 && is_assignable_v<typename T::reference, typename T::element_type> && T::is_always_unique(); template<class T> concept inout-matrix = is-mdspan<T> && T::rank() == 2 && is_assignable_v<typename T::reference, typename T::element_type> && T::is_always_unique(); template<class T> constexpr bool is-layout-blas-packed = false; / exposition only template<class Triangle, class StorageOrder> constexpr bool is-layout-blas-packed<layout_blas_packed<Triangle, StorageOrder>> = true; template<class T> concept possibly-packed-out-matrix = is-mdspan<T> && T::rank() == 2 && is_assignable_v<typename T::reference, typename T::element_type> && (T::is_always_unique() || is-layout-blas-packed<typename T::layout_type>); template<class T> concept in-object = is-mdspan<T> && (T::rank() == 1 || T::rank() == 2); template<class T> concept out-object = is-mdspan<T> && (T::rank() == 1 || T::rank() == 2) && is_assignable_v<typename T::reference, typename T::element_type> && T::is_always_unique(); template<class T> concept inout-object = is-mdspan<T> && (T::rank() == 1 || T::rank() == 2) && is_assignable_v<typename T::reference, typename T::element_type> && T::is_always_unique(); template<class T> concept scalar = semiregular<T> && (!is-mdspan<T>) && (!is_execution_policy_v<T>);
2
#
If a function in [linalg] accesses the elements of a parameter constrained by in-vector, in-matrix, or in-object, those accesses will not modify the elements.
3
#
Unless explicitly permitted, any inout-vector, inout-matrix, inout-object, out-vector, out-matrix, out-object, or possibly-packed-out-matrix parameter of a function in [linalg] shall not overlap any other mdspan parameter of the function.
1
#
[Note 1: 
These exposition-only helper functions use the less constraining input concepts even for the output arguments, because the additional constraint for assignability of elements is not necessary, and they are sometimes used in a context where the third argument is an input type too.
— end note]
template<class MDS1, class MDS2> requires(is-mdspan<MDS1> && is-mdspan<MDS2>) constexpr bool compatible-static-extents(size_t r1, size_t r2) { / exposition only return MDS1::static_extent(r1) == dynamic_extent || MDS2::static_extent(r2) == dynamic_extent || MDS1::static_extent(r1) == MDS2::static_extent(r2); } template<in-vector In1, in-vector In2, in-vector Out> constexpr bool possibly-addable() { / exposition only return compatible-static-extents<Out, In1>(0, 0) && compatible-static-extents<Out, In2>(0, 0) && compatible-static-extents<In1, In2>(0, 0); } template<in-matrix In1, in-matrix In2, in-matrix Out> constexpr bool possibly-addable() { / exposition only return compatible-static-extents<Out, In1>(0, 0) && compatible-static-extents<Out, In1>(1, 1) && compatible-static-extents<Out, In2>(0, 0) && compatible-static-extents<Out, In2>(1, 1) && compatible-static-extents<In1, In2>(0, 0) && compatible-static-extents<In1, In2>(1, 1); } template<in-matrix InMat, in-vector InVec, in-vector OutVec> constexpr bool possibly-multipliable() { / exposition only return compatible-static-extents<OutVec, InMat>(0, 0) && compatible-static-extents<InMat, InVec>(1, 0); } template<in-vector InVec, in-matrix InMat, in-vector OutVec> constexpr bool possibly-multipliable() { / exposition only return compatible-static-extents<OutVec, InMat>(0, 1) && compatible-static-extents<InMat, InVec>(0, 0); } template<in-matrix InMat1, in-matrix InMat2, in-matrix OutMat> constexpr bool possibly-multipliable() { / exposition only return compatible-static-extents<OutMat, InMat1>(0, 0) && compatible-static-extents<OutMat, InMat2>(1, 1) && compatible-static-extents<InMat1, InMat2>(1, 0); }
1
#
[Note 1: 
These exposition-only helper functions use the less constraining input concepts even for the output arguments, because the additional constraint for assignability of elements is not necessary, and they are sometimes used in a context where the third argument is an input type too.
— end note]
constexpr bool addable( / exposition only const in-vector auto& in1, const in-vector auto& in2, const in-vector auto& out) { return out.extent(0) == in1.extent(0) && out.extent(0) == in2.extent(0); } constexpr bool addable( / exposition only const in-matrix auto& in1, const in-matrix auto& in2, const in-matrix auto& out) { return out.extent(0) == in1.extent(0) && out.extent(1) == in1.extent(1) && out.extent(0) == in2.extent(0) && out.extent(1) == in2.extent(1); } constexpr bool multipliable( / exposition only const in-matrix auto& in_mat, const in-vector auto& in_vec, const in-vector auto& out_vec) { return out_vec.extent(0) == in_mat.extent(0) && in_mat.extent(1) == in_vec.extent(0); } constexpr bool multipliable( / exposition only const in-vector auto& in_vec, const in-matrix auto& in_mat, const in-vector auto& out_vec) { return out_vec.extent(0) == in_mat.extent(1) && in_mat.extent(0) == in_vec.extent(0); } constexpr bool multipliable( / exposition only const in-matrix auto& in_mat1, const in-matrix auto& in_mat2, const in-matrix auto& out_mat) { return out_mat.extent(0) == in_mat1.extent(0) && out_mat.extent(1) == in_mat2.extent(1) && in_mat1.extent(1) == in_mat2.extent(0); }

29.9.8 Scaled in-place transformation [linalg.scaled]

1
#
The scaled function takes a value alpha and an mdspan x, and returns a new read-only mdspan that represents the elementwise product of alpha with each element of x.
[Example 1: using Vec = mdspan<double, dextents<size_t, 1>; / z = alpha * x + y void z_equals_alpha_times_x_plus_y(double alpha, Vec x, Vec y, Vec z) { add(scaled(alpha, x), y, z); } / z = alpha * x + beta * y void z_equals_alpha_times_x_plus_beta_times_y(double alpha, Vec x, double beta, Vec y, Vec z) { add(scaled(alpha, x), scaled(beta, y), z); } — end example]

29.9.8.2 Class template scaled_accessor [linalg.scaled.scaledaccessor]

1
#
The class template scaled_accessor is an mdspan accessor policy which upon access produces scaled elements.
It is part of the implementation of scaled ([linalg.scaled.scaled]).
namespace std::linalg { template<class ScalingFactor, class NestedAccessor> class scaled_accessor { public: using element_type = const decltype(declval<ScalingFactor>() * declval<NestedAccessor::element_type>(); using reference = remove_const_t<element_type>; using data_handle_type = NestedAccessor::data_handle_type; using offset_policy = scaled_accessor<ScalingFactor, NestedAccessor::offset_policy>; constexpr scaled_accessor() = default; template<class OtherNestedAccessor> explicit(!is_convertible_v<OtherNestedAccessor, NestedAccessor>) constexpr scaled_accessor(const scaled_accessor<ScalingFactor, OtherNestedAccessor>& other); constexpr scaled_accessor(const ScalingFactor& s, const NestedAccessor& a); constexpr reference access(data_handle_type p, size_t i) const; constexpr offset_policy::data_handle_type offset(data_handle_type p, size_t i) const; constexpr const ScalingFactor& scaling_factor() const noexcept { return scaling-factor; } constexpr const NestedAccessor& nested_accessor() const noexcept { return nested-accessor; } private: ScalingFactor scaling-factor{}; / exposition only NestedAccessor nested-accessor{}; / exposition only }; }
2
#
Mandates:
🔗
template<class OtherNestedAccessor> explicit(!is_convertible_v<OtherNestedAccessor, NestedAccessor>) constexpr scaled_accessor(const scaled_accessor<ScalingFactor, OtherNestedAccessor>& other);
3
#
Effects:
  • (4.1)
    Direct-non-list-initializes scaling-factor with other.scaling_factor(), and
  • (4.2)
    direct-non-list-initializes nested-accessor with other.nested_accessor().
🔗
constexpr scaled_accessor(const ScalingFactor& s, const NestedAccessor& a);
5
#
Effects:
  • (5.1)
    Direct-non-list-initializes scaling-factor with s, and
  • (5.2)
    direct-non-list-initializes nested-accessor with a.
🔗
constexpr reference access(data_handle_type p, size_t i) const;
6
#
Returns: scaling_factor() * NestedAccessor::element_type(nested-accessor.access(p, i))
🔗
constexpr offset_policy::data_handle_type offset(data_handle_type p, size_t i) const;
7
#
The scaled function template takes a scaling factor alpha and an mdspan x, and returns a new read-only mdspan with the same domain as x, that represents the elementwise product of alpha with each element of x.
🔗
template<class ScalingFactor, class ElementType, class Extents, class Layout, class Accessor> constexpr auto scaled(ScalingFactor alpha, mdspan<ElementType, Extents, Layout, Accessor> x);
2
#
Returns: mdspan<typename SA::element_type, Extents, Layout, SA>(x.data_handle(), x.mapping(), SA(alpha, x.accessor()
4
#
[Example 1: void test_scaled(mdspan<double, extents<int, 10> x) { auto x_scaled = scaled(5.0, x); for (int i = 0; i < x.extent(0); ++i) { assert(x_scaled[i] == 5.0 * x[i]); } } — end example]

29.9.9 Conjugated in-place transformation [linalg.conj]

1
#
The conjugated function takes an mdspan x, and returns a new read-only mdspan y with the same domain as x, whose elements are the complex conjugates of the corresponding elements of x.

29.9.9.2 Class template conjugated_accessor [linalg.conj.conjugatedaccessor]

1
#
The class template conjugated_accessor is an mdspan accessor policy which upon access produces conjugate elements.
It is part of the implementation of conjugated ([linalg.conj.conjugated]).
namespace std::linalg { template<class NestedAccessor> class conjugated_accessor { public: using element_type = const decltype(conj-if-needed(declval<NestedAccessor::element_type>(); using reference = remove_const_t<element_type>; using data_handle_type = NestedAccessor::data_handle_type; using offset_policy = conjugated_accessor<NestedAccessor::offset_policy>; constexpr conjugated_accessor() = default; constexpr conjugated_accessor(const NestedAccessor& acc); template<class OtherNestedAccessor> explicit(!is_convertible_v<OtherNestedAccessor, NestedAccessor>) constexpr conjugated_accessor(const conjugated_accessor<OtherNestedAccessor>& other); constexpr reference access(data_handle_type p, size_t i) const; constexpr typename offset_policy::data_handle_type offset(data_handle_type p, size_t i) const; constexpr const NestedAccessor& nested_accessor() const noexcept { return nested-accessor_; } private: NestedAccessor nested-accessor_{}; / exposition only }; }
2
#
Mandates:
  • (2.1)
    element_type is valid and denotes a type,
  • (2.2)
    is_copy_constructible_v<reference> is true,
  • (2.3)
    is_reference_v<element_type> is false, and
  • (2.4)
    NestedAccessor meets the accessor policy requirements ([mdspan.accessor.reqmts]).
🔗
constexpr conjugated_accessor(const NestedAccessor& acc);
3
#
Effects: Direct-non-list-initializes nested-accessor_ with acc.
🔗
template<class OtherNestedAccessor> explicit(!is_convertible_v<OtherNestedAccessor, NestedAccessor>) constexpr conjugated_accessor(const conjugated_accessor<OtherNestedAccessor>& other);
4
#
Constraints: is_constructible_v<NestedAccessor, const OtherNestedAccessor&> is true.
5
#
Effects: Direct-non-list-initializes nested-accessor_ with other.nested_accessor().
🔗
constexpr reference access(data_handle_type p, size_t i) const;
6
#
Returns: conj-if-needed(NestedAccessor​::​element_type(nested-accessor_.access(p, i))
🔗
constexpr typename offset_policy::data_handle_type offset(data_handle_type p, size_t i) const;
7
#
Returns: nested-accessor_.offset(p, i)

29.9.9.3 Function template conjugated [linalg.conj.conjugated]

🔗
template<class ElementType, class Extents, class Layout, class Accessor> constexpr auto conjugated(mdspan<ElementType, Extents, Layout, Accessor> a);
1
#
Let A be
  • (1.1)
    remove_cvref_t<decltype(a.accessor().nested_accessor()> if Accessor is a specialization of conjugated_accessor;
  • (1.2)
    otherwise, Accessor if remove_cvref_t<ElementType> is an arithmetic type;
  • (1.3)
    otherwise, conjugated_accessor<Accessor> if the expression conj(E) is valid for any subexpression E whose type is remove_cvref_t<ElementType> with overload resolution performed in a context that includes the declaration template<class U> U conj(const U&) = delete;
  • (1.4)
    otherwise, Accessor.
2
#
Returns: Let MD be mdspan<typename A​::​element_type, Extents, Layout, A>.
  • (2.1)
    MD(a.data_handle(), a.mapping(), a.accessor().nested_accessor() if Accessor is a
    specialization of conjugated_accessor;
  • (2.2)
    otherwise, a, if is_same_v<A, Accessor> is true;
  • (2.3)
    otherwise, MD(a.data_handle(), a.mapping(), conjugated_accessor(a.accessor().
3
#
[Example 1: void test_conjugated_complex(mdspan<complex<double>, extents<int, 10> a) { auto a_conj = conjugated(a); for (int i = 0; i < a.extent(0); ++i) { assert(a_conj[i] == conj(a[i]); } auto a_conj_conj = conjugated(a_conj); for (int i = 0; i < a.extent(0); ++i) { assert(a_conj_conj[i] == a[i]); } } void test_conjugated_real(mdspan<double, extents<int, 10> a) { auto a_conj = conjugated(a); for (int i = 0; i < a.extent(0); ++i) { assert(a_conj[i] == a[i]); } auto a_conj_conj = conjugated(a_conj); for (int i = 0; i < a.extent(0); ++i) { assert(a_conj_conj[i] == a[i]); } } — end example]

29.9.10 Transpose in-place transformation [linalg.transp]

1
#
layout_transpose is an mdspan layout mapping policy that swaps the two indices, extents, and strides of any unique mdspan layout mapping policy.
2
#
The transposed function takes an mdspan representing a matrix, and returns a new mdspan representing the transpose of the input matrix.

29.9.10.2 Exposition-only helpers for layout_transpose and transposed [linalg.transp.helpers]

1
#
The exposition-only transpose-extents function takes an extents object representing the extents of a matrix, and returns a new extents object representing the extents of the transpose of the matrix.
2
#
The exposition-only alias template transpose-extents-t<InputExtents> gives the type of transpose-extents(e) for a given extents object e of type InputExtents.
🔗
template<class IndexType, size_t InputExtent0, size_t InputExtent1> constexpr extents<IndexType, InputExtent1, InputExtent0> transpose-extents(const extents<IndexType, InputExtent0, InputExtent1>& in); / exposition only
3
#
Returns: extents<IndexType, InputExtent1, InputExtent0>(in.extent(1), in.extent(0)
template<class InputExtents> using transpose-extents-t = decltype(transpose-extents(declval<InputExtents>(); / exposition only

29.9.10.3 Class template layout_transpose [linalg.transp.layout.transpose]

1
#
layout_transpose is an mdspan layout mapping policy that swaps the two indices, extents, and strides of any mdspan layout mapping policy.
namespace std::linalg { template<class Layout> class layout_transpose { public: using nested_layout_type = Layout; template<class Extents> struct mapping { private: using nested-mapping-type = Layout::template mapping<transpose-extents-t<Extents>>; / exposition only public: using extents_type = Extents; using index_type = extents_type::index_type; using size_type = extents_type::size_type; using rank_type = extents_type::rank_type; using layout_type = layout_transpose; constexpr explicit mapping(const nested-mapping-type&); constexpr const extents_type& extents() const noexcept { return extents_; } constexpr index_type required_span_size() const { return nested-mapping_.required_span_size(); } template<class Index0, class Index1> constexpr index_type operator()(Index0 ind0, Index1 ind1) const { return nested-mapping_(ind1, ind0); } constexpr const nested-mapping-type& nested_mapping() const noexcept { return nested-mapping_; } static constexpr bool is_always_unique() noexcept { return nested-mapping-type::is_always_unique(); } static constexpr bool is_always_exhaustive() noexcept { return nested-mapping-type::is_always_exhaustive(); } static constexpr bool is_always_strided() noexcept { return nested-mapping-type::is_always_strided(); } constexpr bool is_unique() const { return nested-mapping_.is_unique(); } constexpr bool is_exhaustive() const { return nested-mapping_.is_exhaustive(); } constexpr bool is_strided() const { return nested-mapping_.is_strided(); } constexpr index_type stride(size_t r) const; template<class OtherExtents> friend constexpr bool operator=(const mapping& x, const mapping<OtherExtents>& y); private: nested-mapping-type nested-mapping_; / exposition only extents_type extents_; / exposition only }; }; }
2
#
Layout shall meet the layout mapping policy requirements ([mdspan.layout.policy.reqmts]).
3
#
Mandates:
  • (3.1)
    Extents is a specialization of std​::​extents, and
  • (3.2)
    Extents​::​rank() equals 2.
🔗
constexpr explicit mapping(const nested-mapping-type& map);
4
#
Effects:
  • (4.1)
    Initializes nested-mapping_ with map, and
  • (4.2)
    initializes extents_ with transpose-extents(map.extents().
🔗
constexpr index_type stride(size_t r) const;
5
#
Returns: nested-mapping_.stride(r == 0 ? 1 : 0)
🔗
template<class OtherExtents> friend constexpr bool operator=(const mapping& x, const mapping<OtherExtents>& y);
7
#
Constraints: The expression x.nested-mapping_ == y.nested-mapping_ is well-formed and its result is convertible to bool.
8
#
The transposed function takes a rank-2 mdspan representing a matrix, and returns a new mdspan representing the input matrix's transpose.
The input matrix's data are not modified, and the returned mdspan accesses the input matrix's data in place.
🔗
template<class ElementType, class Extents, class Layout, class Accessor> constexpr auto transposed(mdspan<ElementType, Extents, Layout, Accessor> a);
2
#
Let ReturnExtents be transpose-extents-t<Extents>.
Let R be mdspan<ElementType, ReturnExtents, ReturnLayout, Accessor>, where ReturnLayout is:
  • (3.1)
    layout_right if Layout is layout_left;
  • (3.2)
    otherwise, layout_left if Layout is layout_right;
  • (3.3)
    otherwise, layout_right_padded<PaddingValue> if Layout is
    layout_left_padded<PaddingValue> for some size_t value PaddingValue;
  • (3.4)
    otherwise, layout_left_padded<PaddingValue> if Layout is
    layout_right_padded<PaddingValue> for some size_t value PaddingValue;
  • (3.5)
    otherwise, layout_stride if Layout is layout_stride;
  • (3.6)
    otherwise, layout_blas_packed<OppositeTriangle, OppositeStorageOrder>, if Layout is
    layout_blas_packed<Triangle, StorageOrder> for some Triangle and StorageOrder, where
    • (3.6.1)
      OppositeTriangle is conditional_t<is_same_v<Triangle, upper_triangle_t>, lower_triangle_t, upper_triangle_t> and
    • (3.6.2)
      OppositeStorageOrder is conditional_t<is_same_v<StorageOrder, column_major_t>, row_major_t, column_major_t>
  • (3.7)
    otherwise, NestedLayout if Layout is layout_transpose<NestedLayout> for some NestedLayout;
  • (3.8)
    otherwise, layout_transpose<Layout>.
4
#
Returns: With ReturnMapping being the type typename ReturnLayout​::​template mapping<ReturnExtents>:
  • (4.1)
    if Layout is layout_left, layout_right, or a specialization of layout_blas_packed, R(a.data_handle(), ReturnMapping(transpose-extents(a.mapping().extents(), a.accessor()
  • (4.2)
    otherwise, R(a.data_handle(), ReturnMapping(transpose-extents(a.mapping().extents(), a.mapping().stride(1), a.accessor() if Layout is layout_left_padded<PaddingValue> for some size_t value PaddingValue;
  • (4.3)
    otherwise, R(a.data_handle(), ReturnMapping(transpose-extents(a.mapping().extents(), a.mapping().stride(0), a.accessor() if Layout is layout_right_padded<PaddingValue> for some size_t value PaddingValue;
  • (4.4)
    otherwise, if Layout is layout_stride, R(a.data_handle(), ReturnMapping(transpose-extents(a.mapping().extents(), array{a.mapping().stride(1), a.mapping().stride(0)}), a.accessor()
  • (4.5)
    otherwise, if Layout is a specialization of layout_transpose, R(a.data_handle(), a.mapping().nested_mapping(), a.accessor()
  • (4.6)
    otherwise, R(a.data_handle(), ReturnMapping(a.mapping(), a.accessor()
5
#
[Example 1: void test_transposed(mdspan<double, extents<size_t, 3, 4> a) { const auto num_rows = a.extent(0); const auto num_cols = a.extent(1); auto a_t = transposed(a); assert(num_rows == a_t.extent(1); assert(num_cols == a_t.extent(0); assert(a.stride(0) == a_t.stride(1); assert(a.stride(1) == a_t.stride(0); for (size_t row = 0; row < num_rows; ++row) { for (size_t col = 0; col < num_rows; ++col) { assert(a[row, col] == a_t[col, row]); } } auto a_t_t = transposed(a_t); assert(num_rows == a_t_t.extent(0); assert(num_cols == a_t_t.extent(1); assert(a.stride(0) == a_t_t.stride(0); assert(a.stride(1) == a_t_t.stride(1); for (size_t row = 0; row < num_rows; ++row) { for (size_t col = 0; col < num_rows; ++col) { assert(a[row, col] == a_t_t[row, col]); } } } — end example]

29.9.11 Conjugate transpose in-place transform [linalg.conjtransposed]

1
#
The conjugate_transposed function returns a conjugate transpose view of an object.
This combines the effects of transposed and conjugated.
🔗
template<class ElementType, class Extents, class Layout, class Accessor> constexpr auto conjugate_transposed(mdspan<ElementType, Extents, Layout, Accessor> a);
2
#
[Example 1: void test_conjugate_transposed(mdspan<complex<double>, extents<size_t, 3, 4> a) { const auto num_rows = a.extent(0); const auto num_cols = a.extent(1); auto a_ct = conjugate_transposed(a); assert(num_rows == a_ct.extent(1); assert(num_cols == a_ct.extent(0); assert(a.stride(0) == a_ct.stride(1); assert(a.stride(1) == a_ct.stride(0); for (size_t row = 0; row < num_rows; ++row) { for (size_t col = 0; col < num_rows; ++col) { assert(a[row, col] == conj(a_ct[col, row]); } } auto a_ct_ct = conjugate_transposed(a_ct); assert(num_rows == a_ct_ct.extent(0); assert(num_cols == a_ct_ct.extent(1); assert(a.stride(0) == a_ct_ct.stride(0); assert(a.stride(1) == a_ct_ct.stride(1); for (size_t row = 0; row < num_rows; ++row) { for (size_t col = 0; col < num_rows; ++col) { assert(a[row, col] == a_ct_ct[row, col]); assert(conj(a_ct[col, row]) == a_ct_ct[row, col]); } } } — end example]

29.9.12 Algorithm requirements based on template parameter name [linalg.algs.reqs]

1
#
Throughout [linalg.algs.blas1], [linalg.algs.blas2], and [linalg.algs.blas3], where the template parameters are not constrained, the names of template parameters are used to express the following constraints.
[Note 1: 
Function templates that have a template parameter named ExecutionPolicy are parallel algorithms ([algorithms.parallel.defns]).
— end note]

29.9.13 BLAS 1 algorithms [linalg.algs.blas1]

1
#
Complexity: All algorithms in [linalg.algs.blas1] with mdspan parameters perform a count of mdspan array accesses and arithmetic operations that is linear in the maximum product of extents of any mdspan parameter.
🔗
template<class Real> setup_givens_rotation_result<Real> setup_givens_rotation(Real a, Real b) noexcept; template<class Real> setup_givens_rotation_result<complex<Real>> setup_givens_rotation(complex<Real> a, complex<Real> b) noexcept;
1
#
These functions compute the Givens plane rotation represented by the two values c and s such that the 2 x 2 system of equations
holds, where c is always a real scalar, and
That is, c and s represent a 2 x 2 matrix, that when multiplied by the right by the input vector whose components are a and b, produces a result vector whose first component r is the Euclidean norm of the input vector, and whose second component is zero.
[Note 1: 
These functions correspond to the LAPACK function xLARTG[bib].
— end note]
2
#
Returns: c, s, r, where c and s form the Givens plane rotation corresponding to the input a and b, and r is the Euclidean norm of the two-component vector formed by a and b.

29.9.13.2.2 Apply a computed Givens rotation to vectors [linalg.algs.blas1.givens.rot]

🔗
template<inout-vector InOutVec1, inout-vector InOutVec2, class Real> void apply_givens_rotation(InOutVec1 x, InOutVec2 y, Real c, Real s); template<class ExecutionPolicy, inout-vector InOutVec1, inout-vector InOutVec2, class Real> void apply_givens_rotation(ExecutionPolicy&& exec, InOutVec1 x, InOutVec2 y, Real c, Real s); template<inout-vector InOutVec1, inout-vector InOutVec2, class Real> void apply_givens_rotation(InOutVec1 x, InOutVec2 y, Real c, complex<Real> s); template<class ExecutionPolicy, inout-vector InOutVec1, inout-vector InOutVec2, class Real> void apply_givens_rotation(ExecutionPolicy&& exec, InOutVec1 x, InOutVec2 y, Real c, complex<Real> s);
1
#
Effects: Applies the plane rotation specified by c and s to the input vectors x and y, as if the rotation were a 2 x 2 matrix and the input vectors were successive rows of a matrix with two rows.

29.9.13.3 Swap matrix or vector elements [linalg.algs.blas1.swap]

🔗
template<inout-object InOutObj1, inout-object InOutObj2> void swap_elements(InOutObj1 x, InOutObj2 y); template<class ExecutionPolicy, inout-object InOutObj1, inout-object InOutObj2> void swap_elements(ExecutionPolicy&& exec, InOutObj1 x, InOutObj2 y);
1
#
Mandates: For all r in the range [0, x.rank()), compatible-static-extents<InOutObj1, InOutObj2>(r, r) is true.
4
#
Effects: Swaps all corresponding elements of x and y.

29.9.13.4 Multiply the elements of an object in place by a scalar [linalg.algs.blas1.scal]

🔗
template<scalar Scalar, inout-object InOutObj> void scale(Scalar alpha, InOutObj x); template<class ExecutionPolicy, scalar Scalar, inout-object InOutObj> void scale(ExecutionPolicy&& exec, Scalar alpha, InOutObj x);
1
#
Effects: Overwrites x with the result of computing the elementwise multiplication αx, where the scalar α is alpha.

29.9.13.5 Copy elements of one matrix or vector into another [linalg.algs.blas1.copy]

🔗
template<in-object InObj, out-object OutObj> void copy(InObj x, OutObj y); template<class ExecutionPolicy, in-object InObj, out-object OutObj> void copy(ExecutionPolicy&& exec, InObj x, OutObj y);
1
#
Mandates: For all r in the range
4
#
Effects: Assigns each element of x to the corresponding element of y.

29.9.13.6 Add vectors or matrices elementwise [linalg.algs.blas1.add]

🔗
template<in-object InObj1, in-object InObj2, out-object OutObj> void add(InObj1 x, InObj2 y, OutObj z); template<class ExecutionPolicy, in-object InObj1, in-object InObj2, out-object OutObj> void add(ExecutionPolicy&& exec, InObj1 x, InObj2 y, OutObj z);
1
#
Preconditions: addable(x,y,z) is true.
5
#
[Note 1: 
The functions in this section correspond to the BLAS functions xDOT, xDOTU, and xDOTC[bib].
— end note]
2
#
Preconditions: v1.extent(0) equals v2.extent(0).
🔗
template<in-vector InVec1, in-vector InVec2, scalar Scalar> Scalar dot(InVec1 v1, InVec2 v2, Scalar init); template<class ExecutionPolicy, in-vector InVec1, in-vector InVec2, scalar Scalar> Scalar dot(ExecutionPolicy&& exec, InVec1 v1, InVec2 v2, Scalar init);
5
#
These functions compute a non-conjugated dot product with an explicitly specified result type.
6
#
Returns: Let N be v1.extent(0).
  • (6.1)
    init if N is zero;
  • (6.2)
    otherwise, GENERALIZED_SUM(plus<>(), init, v1[0]*v2[0], …, v1[N-1]*v2[N-1]).
7
#
Remarks: If InVec1​::​value_type, InVec2​::​value_type, and Scalar are all floating-point types or specializations of complex, and if Scalar has higher precision than InVec1​::​value_type or InVec2​::​value_type, then intermediate terms in the sum use Scalar's precision or greater.
🔗
template<in-vector InVec1, in-vector InVec2> auto dot(InVec1 v1, InVec2 v2); template<class ExecutionPolicy, in-vector InVec1, in-vector InVec2> auto dot(ExecutionPolicy&& exec, InVec1 v1, InVec2 v2);
8
#
Effects: Let T be decltype(declval<typename InVec1​::​value_type>() * declval<typename InVec2​::​value_type>().
Then,
  • (9.1)
    the two-parameter overload is equivalent to: return dot(v1, v2, T{}); and
  • (9.2)
    the three-parameter overload is equivalent to: return dot(std::forward<ExecutionPolicy>(exec), v1, v2, T{});
🔗
template<in-vector InVec1, in-vector InVec2, scalar Scalar> Scalar dotc(InVec1 v1, InVec2 v2, Scalar init); template<class ExecutionPolicy, in-vector InVec1, in-vector InVec2, scalar Scalar> Scalar dotc(ExecutionPolicy&& exec, InVec1 v1, InVec2 v2, Scalar init);
10
#
These functions compute a conjugated dot product with an explicitly specified result type.
11
#
Effects:
  • (11.1)
    The three-parameter overload is equivalent to: return dot(conjugated(v1), v2, init); and
  • (11.2)
    the four-parameter overload is equivalent to: return dot(std::forward<ExecutionPolicy>(exec), conjugated(v1), v2, init);
🔗
template<in-vector InVec1, in-vector InVec2> auto dotc(InVec1 v1, InVec2 v2); template<class ExecutionPolicy, in-vector InVec1, in-vector InVec2> auto dotc(ExecutionPolicy&& exec, InVec1 v1, InVec2 v2);
12
#
Effects: Let T be decltype(conj-if-needed(declval<typename InVec1​::​value_type>() * declval<typename InVec2​::​value_type>().
Then,
  • (13.1)
    the two-parameter overload is equivalent to: return dotc(v1, v2, T{}); and
  • (13.2)
    the three-parameter overload is equivalent to return dotc(std::forward<ExecutionPolicy>(exec), v1, v2, T{});

29.9.13.8 Euclidean norm of a vector [linalg.algs.blas1.nrm2]

🔗
template<in-vector InVec, scalar Scalar> Scalar vector_two_norm(InVec v, Scalar init); template<class ExecutionPolicy, in-vector InVec, scalar Scalar> Scalar vector_two_norm(ExecutionPolicy&& exec, InVec v, Scalar init);
1
#
Mandates: InVec​::​value_type and Scalar are either a floating-point type, or a specialization of complex.
Let a be abs-if-needed(declval<typename InVec​::​value_type>().
Then, decltype(init + a * a is convertible to Scalar.
3
#
Returns: The square root of the sum of the square of init and the squares of the absolute values of the elements of v.
[Note 2: 
For init equal to zero, this is the Euclidean norm (also called 2-norm) of the vector v.
— end note]
4
#
Remarks: If Scalar has higher precision than InVec​::​value_type, then intermediate terms in the sum use Scalar's precision or greater.
🔗
template<in-vector InVec> auto vector_two_norm(InVec v); template<class ExecutionPolicy, in-vector InVec> auto vector_two_norm(ExecutionPolicy&& exec, InVec v);
5
#
Effects: Let a be abs-if-needed(declval<typename InVec​::​value_type>().
Let T be decltype(a * a).
Then,
  • (5.1)
    the one-parameter overload is equivalent to: return vector_two_norm(v, T{}); and
  • (5.2)
    the two-parameter overload is equivalent to: return vector_two_norm(std::forward<ExecutionPolicy>(exec), v, T{});

29.9.13.9 Sum of absolute values of vector elements [linalg.algs.blas1.asum]

🔗
template<in-vector InVec, scalar Scalar> Scalar vector_abs_sum(InVec v, Scalar init); template<class ExecutionPolicy, in-vector InVec, scalar Scalar> Scalar vector_abs_sum(ExecutionPolicy&& exec, InVec v, Scalar init);
1
#
[Note 1: 
These functions correspond to the BLAS functions SASUM, DASUM, SCASUM, and DZASUM[bib].
— end note]
2
#
Mandates: decltype(init + abs-if-needed(real-if-needed(declval<typename InVec::value_type>() + abs-if-needed(imag-if-needed(declval<typename InVec::value_type>() is convertible to Scalar.
3
#
Returns: Let N be v.extent(0).
  • (3.1)
    init if N is zero;
  • (3.2)
    otherwise, if InVec​::​value_type is an arithmetic type, GENERALIZED_SUM(plus<>(), init, abs-if-needed(v[0]), …, abs-if-needed(v[N-1])
  • (3.3)
    otherwise, GENERALIZED_SUM(plus<>(), init, abs-if-needed(real-if-needed(v[0]) + abs-if-needed(imag-if-needed(v[0]), …, abs-if-needed(real-if-needed(v[N-1]) + abs-if-needed(imag-if-needed(v[N-1])
4
#
Remarks: If InVec​::​value_type and Scalar are all floating-point types or specializations of complex, and if Scalar has higher precision than InVec​::​value_type, then intermediate terms in the sum use Scalar's precision or greater.
🔗
template<in-vector InVec> auto vector_abs_sum(InVec v); template<class ExecutionPolicy, in-vector InVec> auto vector_abs_sum(ExecutionPolicy&& exec, InVec v);
5
#
Effects: Let T be typename InVec​::​value_type.
Then,
  • (5.1)
    the one-parameter overload is equivalent to: return vector_abs_sum(v, T{}); and
  • (5.2)
    the two-parameter overload is equivalent to: return vector_abs_sum(std::forward<ExecutionPolicy>(exec), v, T{});

29.9.13.10 Index of maximum absolute value of vector elements [linalg.algs.blas1.iamax]

🔗
template<in-vector InVec> typename InVec::extents_type vector_idx_abs_max(InVec v); template<class ExecutionPolicy, in-vector InVec> typename InVec::extents_type vector_idx_abs_max(ExecutionPolicy&& exec, InVec v);
1
#
Let T be decltype(abs-if-needed(real-if-needed(declval<typename InVec::value_type>() + abs-if-needed(imag-if-needed(declval<typename InVec::value_type>()
3
#
Returns:
  • (4.1)
    numeric_limits<typename InVec​::​size_type>​::​max() if v has zero elements;
  • (4.2)
    otherwise, the index of the first element of v having largest absolute value, if InVec​::​value_type is an arithmetic type;
  • (4.3)
    otherwise, the index of the first element

29.9.13.11 Frobenius norm of a matrix [linalg.algs.blas1.matfrobnorm]

1
#
[Note 1: 
These functions exist in the BLAS standard[bib] but are not part of the reference implementation.
— end note]
🔗
template<in-matrix InMat, scalar Scalar> Scalar matrix_frob_norm(InMat A, Scalar init); template<class ExecutionPolicy, in-matrix InMat, scalar Scalar> Scalar matrix_frob_norm(ExecutionPolicy&& exec, InMat A, Scalar init);
2
#
Mandates: InVec​::​value_type and Scalar are either a floating-point type, or a specialization of complex.
Let a be abs-if-needed(declval<typename InMat​::​value_type>().
Then, decltype(init + a * a) is convertible to Scalar.
3
#
Returns: The square root of the sum of squares of init and the absolute values of the elements of A.
[Note 2: 
For init equal to zero, this is the Frobenius norm of the matrix A.
— end note]
4
#
Remarks: If Scalar has higher precision than InMat​::​value_type, then intermediate terms in the sum use Scalar's precision or greater.
🔗
template<in-matrix InMat> auto matrix_frob_norm(InMat A); template<class ExecutionPolicy, in-matrix InMat> auto matrix_frob_norm(ExecutionPolicy&& exec, InMat A);
5
#
Effects: Let a be abs-if-needed(declval<typename InMat​::​value_type>().
Let T be decltype(a * a).
Then,
  • (5.1)
    the one-parameter overload is equivalent to: return matrix_frob_norm(A, T{}); and
  • (5.2)
    the two-parameter overload is equivalent to: return matrix_frob_norm(std::forward<ExecutionPolicy>(exec), A, T{});
1
#
[Note 1: 
These functions exist in the BLAS standard[bib] but are not part of the reference implementation.
— end note]
🔗
template<in-matrix InMat, scalar Scalar> Scalar matrix_one_norm(InMat A, Scalar init); template<class ExecutionPolicy, in-matrix InMat, scalar Scalar> Scalar matrix_one_norm(ExecutionPolicy&& exec, InMat A, Scalar init);
2
#
Mandates: decltype(abs-if-needed(declval<typename InMat​::​value_type>() is convertible to Scalar.
3
#
Returns:
  • (3.1)
    init if A.extent(1) is zero;
  • (3.2)
    otherwise, the sum of init and the one norm of the matrix A.
[Note 2: 
The one norm of the matrix A is the maximum over all columns of A, of the sum of the absolute values of the elements of the column.
— end note]
4
#
Remarks: If InMat​::​value_type and Scalar are all floating-point types or specializations of complex, and if Scalar has higher precision than InMat​::​value_type, then intermediate terms in the sum use Scalar's precision or greater.
🔗
template<in-matrix InMat> auto matrix_one_norm(InMat A); template<class ExecutionPolicy, in-matrix InMat> auto matrix_one_norm(ExecutionPolicy&& exec, InMat A);
5
#
Effects: Let T be decltype(abs-if-needed(declval<typename InMat​::​value_type>().
Then,
  • (5.1)
    the one-parameter overload is equivalent to: return matrix_one_norm(A, T{}); and
  • (5.2)
    the two-parameter overload is equivalent to: return matrix_one_norm(std::forward<ExecutionPolicy>(exec), A, T{});

29.9.13.13 Infinity norm of a matrix [linalg.algs.blas1.matinfnorm]

1
#
[Note 1: 
These functions exist in the BLAS standard[bib] but are not part of the reference implementation.
— end note]
🔗
template<in-matrix InMat, scalar Scalar> Scalar matrix_inf_norm(InMat A, Scalar init); template<class ExecutionPolicy, in-matrix InMat, scalar Scalar> Scalar matrix_inf_norm(ExecutionPolicy&& exec, InMat A, Scalar init);
2
#
Mandates: decltype(abs-if-needed(declval<typename InMat​::​value_type>() is convertible to Scalar.
3
#
Returns:
  • (3.1)
    init if A.extent(0) is zero;
  • (3.2)
    otherwise, the sum of init and the infinity norm of the matrix A.
[Note 2: 
The infinity norm of the matrix A is the maximum over all rows of A, of the sum of the absolute values of the elements of the row.
— end note]
4
#
Remarks: If InMat​::​value_type and Scalar are all floating-point types or specializations of complex, and if Scalar has higher precision than InMat​::​value_type, then intermediate terms in the sum use Scalar's precision or greater.
🔗
template<in-matrix InMat> auto matrix_inf_norm(InMat A); template<class ExecutionPolicy, in-matrix InMat> auto matrix_inf_norm(ExecutionPolicy&& exec, InMat A);
5
#
Effects: Let T be decltype(abs-if-needed(declval<typename InMat​::​value_type>().
Then,
  • (5.1)
    the one-parameter overload is equivalent to: return matrix_inf_norm(A, T{}); and
  • (5.2)
    the two-parameter overload is equivalent to: return matrix_inf_norm(std::forward<ExecutionPolicy>(exec), A, T{});

29.9.14 BLAS 2 algorithms [linalg.algs.blas2]

29.9.14.1 General matrix-vector product [linalg.algs.blas2.gemv]

1
#
Mandates:
  • (3.1)
    possibly-multipliable<decltype(A), decltype(x), decltype(y)>() is true, and
  • (3.2)
    possibly-addable<decltype(y), decltype(y), decltype(z)>() is true for those overloads that take a z parameter.
4
#
Complexity:
🔗
template<in-matrix InMat, in-vector InVec, out-vector OutVec> void matrix_vector_product(InMat A, InVec x, OutVec y); template<class ExecutionPolicy, in-matrix InMat, in-vector InVec, out-vector OutVec> void matrix_vector_product(ExecutionPolicy&& exec, InMat A, InVec x, OutVec y);
6
#
Effects: Computes
[Example 1: constexpr size_t num_rows = 5; constexpr size_t num_cols = 6; / y = 3.0 * A * x void scaled_matvec_1(mdspan<double, extents<size_t, num_rows, num_cols>> A, mdspan<double, extents<size_t, num_cols>> x, mdspan<double, extents<size_t, num_rows>> y) { matrix_vector_product(scaled(3.0, A), x, y); } / z = 7.0 times the transpose of A, times y void scaled_transposed_matvec(mdspan<double, extents<size_t, num_rows, num_cols>> A, mdspan<double, extents<size_t, num_rows>> y, mdspan<double, extents<size_t, num_cols>> z) { matrix_vector_product(scaled(7.0, transposed(A)), y, z); } — end example]
🔗
template<in-matrix InMat, in-vector InVec1, in-vector InVec2, out-vector OutVec> void matrix_vector_product(InMat A, InVec1 x, InVec2 y, OutVec z); template<class ExecutionPolicy, in-matrix InMat, in-vector InVec1, in-vector InVec2, out-vector OutVec> void matrix_vector_product(ExecutionPolicy&& exec, InMat A, InVec1 x, InVec2 y, OutVec z);
8
#
Remarks: z may alias y.
[Example 2: / y = 3.0 * A * x + 2.0 * y void scaled_matvec_2(mdspan<double, extents<size_t, num_rows, num_cols>> A, mdspan<double, extents<size_t, num_cols>> x, mdspan<double, extents<size_t, num_rows>> y) { matrix_vector_product(scaled(3.0, A), x, scaled(2.0, y); } — end example]

29.9.14.2 Symmetric matrix-vector product [linalg.algs.blas2.symv]

1
#
[Note 1: 
These functions correspond to the BLAS functions xSYMV and xSPMV[bib].
— end note]
2
#
Mandates:
  • (3.1)
    If InMat has layout_blas_packed layout, then the layout's Triangle template argument has the same type as the function's Triangle template argument;
  • (3.2)
    compatible-static-extents<decltype(A), decltype(A)>(0, 1) is true;
  • (3.3)
    possibly-multipliable<decltype(A), decltype(x), decltype(y)>() is true; and
  • (3.4)
    possibly-addable<decltype(y), decltype(y), decltype(z)>() is true for those overloads that take a z parameter.
4
#
Preconditions:
  • (4.1)
    A.extent(0) equals A.extent(1),
  • (4.2)
    multipliable(A,x,y) is true, and
  • (4.3)
    addable(y,y,z) is true for those overloads that take a z parameter.
5
#
Complexity:
🔗
template<in-matrix InMat, class Triangle, in-vector InVec, out-vector OutVec> void symmetric_matrix_vector_product(InMat A, Triangle t, InVec x, OutVec y); template<class ExecutionPolicy, in-matrix InMat, class Triangle, in-vector InVec, out-vector OutVec> void symmetric_matrix_vector_product(ExecutionPolicy&& exec, InMat A, Triangle t, InVec x, OutVec y);
6
#
These functions perform an overwriting symmetric matrix-vector product, taking into account the Triangle parameter that applies to the symmetric matrix A ([linalg.general]).
7
#
Effects: Computes
🔗
template<in-matrix InMat, class Triangle, in-vector InVec1, in-vector InVec2, out-vector OutVec> void symmetric_matrix_vector_product(InMat A, Triangle t, InVec1 x, InVec2 y, OutVec z); template<class ExecutionPolicy, in-matrix InMat, class Triangle, in-vector InVec1, in-vector InVec2, out-vector OutVec> void symmetric_matrix_vector_product(ExecutionPolicy&& exec, InMat A, Triangle t, InVec1 x, InVec2 y, OutVec z);
8
#
These functions perform an updating symmetric matrix-vector product, taking into account the Triangle parameter that applies to the symmetric matrix A ([linalg.general]).
9
#
[Note 1: 
These functions correspond to the BLAS functions xHEMV and xHPMV[bib].
— end note]
2
#
Mandates:
  • (3.1)
    If InMat has layout_blas_packed layout, then the layout's Triangle template argument has the same type as the function's Triangle template argument;
  • (3.2)
    compatible-static-extents<decltype(A), decltype(A)>(0, 1) is true;
  • (3.3)
    possibly-multipliable<decltype(A), decltype(x), decltype(y)>() is true; and
  • (3.4)
    possibly-addable<decltype(y), decltype(y), decltype(z)>() is true for those overloads that take a z parameter.
4
#
Complexity:
🔗
template<in-matrix InMat, class Triangle, in-vector InVec, out-vector OutVec> void hermitian_matrix_vector_product(InMat A, Triangle t, InVec x, OutVec y); template<class ExecutionPolicy, in-matrix InMat, class Triangle, in-vector InVec, out-vector OutVec> void hermitian_matrix_vector_product(ExecutionPolicy&& exec, InMat A, Triangle t, InVec x, OutVec y);
6
#
These functions perform an overwriting Hermitian matrix-vector product, taking into account the Triangle parameter that applies to the Hermitian matrix A ([linalg.general]).
7
#
Effects: Computes
🔗
template<in-matrix InMat, class Triangle, in-vector InVec1, in-vector InVec2, out-vector OutVec> void hermitian_matrix_vector_product(InMat A, Triangle t, InVec1 x, InVec2 y, OutVec z); template<class ExecutionPolicy, in-matrix InMat, class Triangle, in-vector InVec1, in-vector InVec2, out-vector OutVec> void hermitian_matrix_vector_product(ExecutionPolicy&& exec, InMat A, Triangle t, InVec1 x, InVec2 y, OutVec z);
8
#
These functions perform an updating Hermitian matrix-vector product, taking into account the Triangle parameter that applies to the Hermitian matrix A ([linalg.general]).
9
#
[Note 1: 
These functions correspond to the BLAS functions xTRMV and xTPMV[bib].
— end note]
2
#
Mandates:
  • (3.1)
    If InMat has layout_blas_packed layout, then the layout's Triangle template argument has the same type as the function's Triangle template argument;
  • (3.2)
    compatible-static-extents<decltype(A), decltype(A)>(0, 1) is true;
  • (3.3)
    compatible-static-extents<decltype(A), decltype(y)>(0, 0) is true;
  • (3.4)
    compatible-static-extents<decltype(A), decltype(x)>(0, 0) is true for those overloads that take an x parameter; and
  • (3.5)
    compatible-static-extents<decltype(A), decltype(z)>(0, 0) is true for those overloads that take a z parameter.
4
#
Preconditions:
  • (4.1)
    A.extent(0) equals A.extent(1),
  • (4.2)
    A.extent(0) equals y.extent(0),
  • (4.3)
    A.extent(0) equals x.extent(0) for those overloads that take an x parameter, and
  • (4.4)
    A.extent(0) equals z.extent(0) for those overloads that take a z parameter.
🔗
template<in-matrix InMat, class Triangle, class DiagonalStorage, in-vector InVec, out-vector OutVec> void triangular_matrix_vector_product(InMat A, Triangle t, DiagonalStorage d, InVec x, OutVec y); template<class ExecutionPolicy, in-matrix InMat, class Triangle, class DiagonalStorage, in-vector InVec, out-vector OutVec> void triangular_matrix_vector_product(ExecutionPolicy&& exec, InMat A, Triangle t, DiagonalStorage d, InVec x, OutVec y);
5
#
These functions perform an overwriting triangular matrix-vector product, taking into account the Triangle and DiagonalStorage parameters that apply to the triangular matrix A ([linalg.general]).
6
#
Complexity:
🔗
template<in-matrix InMat, class Triangle, class DiagonalStorage, inout-vector InOutVec> void triangular_matrix_vector_product(InMat A, Triangle t, DiagonalStorage d, InOutVec y); template<class ExecutionPolicy, in-matrix InMat, class Triangle, class DiagonalStorage, inout-vector InOutVec> void triangular_matrix_vector_product(ExecutionPolicy&& exec, InMat A, Triangle t, DiagonalStorage d, InOutVec y);
8
#
These functions perform an in-place triangular matrix-vector product, taking into account the Triangle and DiagonalStorage parameters that apply to the triangular matrix A ([linalg.general]).
[Note 2: 
Performing this operation in place hinders parallelization.
However, other ExecutionPolicy specific optimizations, such as vectorization, are still possible.
— end note]
9
#
Effects: Computes a vector
10
#
Complexity:
🔗
template<in-matrix InMat, class Triangle, class DiagonalStorage, in-vector InVec1, in-vector InVec2, out-vector OutVec> void triangular_matrix_vector_product(InMat A, Triangle t, DiagonalStorage d, InVec1 x, InVec2 y, OutVec z); template<class ExecutionPolicy, in-matrix InMat, class Triangle, class DiagonalStorage, in-vector InVec1, in-vector InVec2, out-vector OutVec> void triangular_matrix_vector_product(ExecutionPolicy&& exec, InMat A, Triangle t, DiagonalStorage d, InVec1 x, InVec2 y, OutVec z);
11
#
These functions perform an updating triangular matrix-vector product, taking into account the Triangle and DiagonalStorage parameters that apply to the triangular matrix A ([linalg.general]).
12
#
[Note 1: 
These functions correspond to the BLAS functions xTRSV and xTPSV[bib].
— end note]
2
#
Mandates:
  • (3.1)
    If InMat has layout_blas_packed layout, then the layout's Triangle template argument has the same type as the function's Triangle template argument;
  • (3.2)
    compatible-static-extents<decltype(A), decltype(A)>(0, 1) is true;
  • (3.3)
    compatible-static-extents<decltype(A), decltype(b)>(0, 0) is true; and
  • (3.4)
    compatible-static-extents<decltype(A), decltype(x)>(0, 0) is true for those overloads that take an x parameter.
4
#
Preconditions:
  • (4.1)
    A.extent(0) equals A.extent(1),
  • (4.2)
    A.extent(0) equals b.extent(0), and
  • (4.3)
    A.extent(0) equals x.extent(0) for those overloads that take an x parameter.
🔗
template<in-matrix InMat, class Triangle, class DiagonalStorage, in-vector InVec, out-vector OutVec, class BinaryDivideOp> void triangular_matrix_vector_solve(InMat A, Triangle t, DiagonalStorage d, InVec b, OutVec x, BinaryDivideOp divide); template<class ExecutionPolicy, in-matrix InMat, class Triangle, class DiagonalStorage, in-vector InVec, out-vector OutVec, class BinaryDivideOp> void triangular_matrix_vector_solve(ExecutionPolicy&& exec, InMat A, Triangle t, DiagonalStorage d, InVec b, OutVec x, BinaryDivideOp divide);
5
#
These functions perform a triangular solve, taking into account the Triangle and DiagonalStorage parameters that apply to the triangular matrix A ([linalg.general]).
6
#
Effects: Computes a vector
If no such
7
#
Complexity:
🔗
template<in-matrix InMat, class Triangle, class DiagonalStorage, in-vector InVec, out-vector OutVec> void triangular_matrix_vector_solve(InMat A, Triangle t, DiagonalStorage d, InVec b, OutVec x);
8
#
Effects: Equivalent to: triangular_matrix_vector_solve(A, t, d, b, x, divides<void>{});
🔗
template<class ExecutionPolicy, in-matrix InMat, class Triangle, class DiagonalStorage, in-vector InVec, out-vector OutVec> void triangular_matrix_vector_solve(ExecutionPolicy&& exec, InMat A, Triangle t, DiagonalStorage d, InVec b, OutVec x);
9
#
Effects: Equivalent to: triangular_matrix_vector_solve(std::forward<ExecutionPolicy>(exec), A, t, d, b, x, divides<void>{});
🔗
template<in-matrix InMat, class Triangle, class DiagonalStorage, inout-vector InOutVec, class BinaryDivideOp> void triangular_matrix_vector_solve(InMat A, Triangle t, DiagonalStorage d, InOutVec b, BinaryDivideOp divide); template<class ExecutionPolicy, in-matrix InMat, class Triangle, class DiagonalStorage, inout-vector InOutVec, class BinaryDivideOp> void triangular_matrix_vector_solve(ExecutionPolicy&& exec, InMat A, Triangle t, DiagonalStorage d, InOutVec b, BinaryDivideOp divide);
10
#
These functions perform an in-place triangular solve, taking into account the Triangle and DiagonalStorage parameters that apply to the triangular matrix A ([linalg.general]).
[Note 2: 
Performing triangular solve in place hinders parallelization.
However, other ExecutionPolicy specific optimizations, such as vectorization, are still possible.
— end note]
11
#
Effects: Computes a vector
If no such
12
#
Complexity:
🔗
template<in-matrix InMat, class Triangle, class DiagonalStorage, inout-vector InOutVec> void triangular_matrix_vector_solve(InMat A, Triangle t, DiagonalStorage d, InOutVec b);
13
#
Effects: Equivalent to: triangular_matrix_vector_solve(A, t, d, b, divides<void>{});
🔗
template<class ExecutionPolicy, in-matrix InMat, class Triangle, class DiagonalStorage, inout-vector InOutVec> void triangular_matrix_vector_solve(ExecutionPolicy&& exec, InMat A, Triangle t, DiagonalStorage d, InOutVec b);
14
#
Effects: Equivalent to: triangular_matrix_vector_solve(std::forward<ExecutionPolicy>(exec), A, t, d, b, divides<void>{});

29.9.14.6 Rank-1 (outer product) update of a matrix [linalg.algs.blas2.rank1]

1
#
Mandates:
  • (2.1)
    possibly-multipliable<OutMat, InVec2, InVec1>() is true, and
  • (2.2)
    possibly-addable<OutMat, InMat, OutMat>() is true for those overloads with an E parameter.
3
#
Preconditions:
  • (3.1)
    multipliable(A, y, x) is true, and
  • (3.2)
    addable(A, E, A) is true for those overloads with an E parameter.
4
#
Complexity:
🔗
template<in-vector InVec1, in-vector InVec2, out-matrix OutMat> void matrix_rank_1_update(InVec1 x, InVec2 y, OutMat A); template<class ExecutionPolicy, in-vector InVec1, in-vector InVec2, out-matrix OutMat> void matrix_rank_1_update(ExecutionPolicy&& exec, InVec1 x, InVec2 y, OutMat A);
5
#
These functions perform an overwriting nonsymmetric nonconjugated rank-1 update.
[Note 1: 
These functions correspond to the BLAS functions xGER (for real element types) and xGERU (for complex element types)[bib].
— end note]
6
#
Effects: Computes
🔗
template<in-vector InVec1, in-vector InVec2, in-matrix InMat, out-matrix OutMat> void matrix_rank_1_update(InVec1 x, InVec2 y, InMat E, OutMat A); template<class ExecutionPolicy, in-vector InVec1, in-vector InVec2, in-matrix InMat, out-matrix OutMat> void matrix_rank_1_update(ExecutionPolicy&& exec, InVec1 x, InVec2 y, InMat E, OutMat A);
7
#
These functions perform an updating nonsymmetric nonconjugated rank-1 update.
[Note 2: 
These functions correspond to the BLAS functions xGER (for real element types) and xGERU (for complex element types)[bib].
— end note]
8
#
Remarks: A may alias E.
🔗
template<in-vector InVec1, in-vector InVec2, out-matrix OutMat> void matrix_rank_1_update_c(InVec1 x, InVec2 y, OutMat A); template<class ExecutionPolicy, in-vector InVec1, in-vector InVec2, out-matrix OutMat> void matrix_rank_1_update_c(ExecutionPolicy&& exec, InVec1 x, InVec2 y, OutMat A);
10
#
These functions perform an overwriting nonsymmetric conjugated rank-1 update.
[Note 3: 
These functions correspond to the BLAS functions xGER (for real element types) and xGERC (for complex element types)[bib].
— end note]
11
#
Effects:
  • (11.1)
    For the overloads without an ExecutionPolicy argument, equivalent to: matrix_rank_1_update(x, conjugated(y), A);
  • (11.2)
    otherwise, equivalent to: matrix_rank_1_update(std::forward<ExecutionPolicy>(exec), x, conjugated(y), A);
🔗
template<in-vector InVec1, in-vector InVec2, in-matrix InMat, out-matrix OutMat> void matrix_rank_1_update_c(InVec1 x, InVec2 y, InMat E, OutMat A); template<class ExecutionPolicy, in-vector InVec1, in-vector InVec2, in-matrix InMat, out-matrix OutMat> void matrix_rank_1_update_c(ExecutionPolicy&& exec, InVec1 x, InVec2 y, InMat E, OutMat A);
12
#
These functions perform an updating nonsymmetric conjugated rank-1 update.
[Note 4: 
These functions correspond to the BLAS functions xGER (for real element types) and xGERC (for complex element types)[bib].
— end note]
13
#
Effects:
  • (13.1)
    For the overloads without an ExecutionPolicy argument, equivalent to: matrix_rank_1_update(x, conjugated(y), A);
  • (13.2)
    otherwise, equivalent to: matrix_rank_1_update(std::forward<ExecutionPolicy>(exec), x, conjugated(y), E, A);

29.9.14.7 Symmetric or Hermitian Rank-1 (outer product) update of a matrix [linalg.algs.blas2.symherrank1]

1
#
[Note 1: 
These functions correspond to the BLAS functions xSYR, xSPR, xHER, and xHPR[bib].
They have overloads taking a scaling factor alpha, because it would be impossible to express the update
— end note]
2
#
For any function F in this subclause with a parameter named t, an InMat template parameter, and a function parameter InMat E, t applies to accesses done through the parameter E.
F only accesses the triangle of E specified by t.
For accesses of diagonal elements E[i, i], F only uses the value real-if-needed(E[i, i]) if the name of F starts with hermitian.
For accesses E[i, j] outside the triangle specified by t, F only uses the value
  • (3.1)
    conj-if-needed(E[j, i]) if the name of F starts with hermitian, or
  • (3.2)
    E[j, i] if the name of F starts with symmetric.
4
#
Mandates:
  • (4.1)
    If OutMat has layout_blas_packed layout, then the layout's Triangle template argument has the same type as the function's Triangle template argument;
  • (4.2)
    compatible-static-extents<decltype(A), decltype(A)>(0, 1) is true;
  • (4.3)
    compatible-static-extents<decltype(A), decltype(x)>(0, 0) is true; and
  • (4.4)
    possibly-addable<decltype(A), decltype(E), decltype(A)>() is true for those overloads with an E parameter.
5
#
Preconditions:
  • (5.1)
    A.extent(0) equals A.extent(1),
  • (5.2)
    A.extent(0) equals x.extent(0), and
  • (5.3)
    addable(A, E, A) is true for those overloads with an E parameter.
6
#
Complexity:
🔗
template<scalar Scalar, in-vector InVec, possibly-packed-out-matrix OutMat, class Triangle> void symmetric_matrix_rank_1_update(Scalar alpha, InVec x, OutMat A, Triangle t); template<class ExecutionPolicy, scalar Scalar, in-vector InVec, possibly-packed-out-matrix OutMat, class Triangle> void symmetric_matrix_rank_1_update(ExecutionPolicy&& exec, Scalar alpha, InVec x, OutMat A, Triangle t);
7
#
These functions perform an overwriting symmetric rank-1 update of the symmetric matrix A, taking into account the Triangle parameter that applies to A ([linalg.general]).
8
#
Effects: Computes a matrix
🔗
template<scalar Scalar, in-vector InVec, in-matrix InMat, possibly-packed-out-matrix OutMat, class Triangle> void symmetric_matrix_rank_1_update(Scalar alpha, InVec x, InMat E, OutMat A, Triangle t); template<class ExecutionPolicy, scalar Scalar, in-vector InVec, in-matrix InMat, possibly-packed-out-matrix OutMat, class Triangle> void symmetric_matrix_rank_1_update(ExecutionPolicy&& exec, Scalar alpha, InVec x, InMat E, OutMat A, Triangle t);
9
#
These functions perform an updating symmetric rank-1 update of the symmetric matrix A using the symmetric matrix E, taking into account the Triangle parameter that applies to A and E ([linalg.general]).
10
#
Effects: Computes
11
#
Remarks: A may alias E.
🔗
template<scalar Scalar, in-vector InVec, possibly-packed-out-matrix OutMat, class Triangle> void hermitian_matrix_rank_1_update(Scalar alpha, InVec x, OutMat A, Triangle t); template<class ExecutionPolicy, scalar Scalar, in-vector InVec, possibly-packed-out-matrix OutMat, class Triangle> void hermitian_matrix_rank_1_update(ExecutionPolicy&& exec, Scalar alpha, InVec x, OutMat A, Triangle t);
12
#
These functions perform an overwriting Hermitian rank-1 update of the Hermitian matrix A, taking into account the Triangle parameter that applies to A ([linalg.general]).
13
#
Effects: Computes
🔗
template<scalar Scalar, possibly-packed-out-matrix OutMat, class Triangle> void hermitian_matrix_rank_1_update(InVec x, OutMat A, Triangle t); template<class ExecutionPolicy, scalar Scalar, possibly-packed-out-matrix OutMat, class Triangle> void hermitian_matrix_rank_1_update(ExecutionPolicy&& exec, InVec x, OutMat A, Triangle t);
14
#
These functions perform an updating Hermitian rank-1 update of the Hermitian matrix A using the Hermitian matrix E, taking into account the Triangle parameter that applies to A and E ([linalg.general]).
15
#
Effects: Computes
16
#
[Note 1: 
These functions correspond to the BLAS functions xSYR2,xSPR2, xHER2 and xHPR2[bib].
— end note]
2
#
For any function F in this subclause with a parameter named t, an InMat template parameter, and a function parameter InMat E, t applies to accesses done through the parameter E.
F only accesses the triangle of E specified by t.
For accesses of diagonal elements E[i, i], F only uses the value real-if-needed(E[i, i]) if the name of F starts with hermitian.
For accesses E[i, j] outside the triangle specified by t, F only uses the value
  • (3.1)
    conj-if-needed(E[j, i]) if the name of F starts with hermitian, or
  • (3.2)
    E[j, i] if the name of F starts with symmetric.
4
#
Mandates:
  • (4.1)
    If OutMat has layout_blas_packed layout, then the layout's Triangle template argument has the same type as the function's Triangle template argument;
  • (4.2)
    If the function has an InMat template parameter and InMat has layout_blas_packed layout, then the layout's Triangle template argument has the same type as the function's Triangle template argument;
  • (4.3)
    compatible-static-extents<decltype(A), decltype(A)>(0, 1) is true;
  • (4.4)
    possibly-multipliable<decltype(A), decltype(x), decltype(y)>() is true; and
  • (4.5)
    possibly-addable<decltype(A), decltype(E), decltype(A)>() is true for those overloads with an E parameter.
5
#
Preconditions:
  • (5.1)
    A.extent(0) equals A.extent(1),
  • (5.2)
    multipliable(A, x, y) is true, and
  • (5.3)
    addable(A, E, A) is true for those overloads with an E parameter.
6
#
Complexity:
🔗
template<in-vector InVec1, in-vector InVec2, possibly-packed-out-matrix OutMat, class Triangle> void symmetric_matrix_rank_2_update(InVec1 x, InVec2 y, OutMat A, Triangle t); template<class ExecutionPolicy, in-vector InVec1, in-vector InVec2, possibly-packed-out-matrix OutMat, class Triangle> void symmetric_matrix_rank_2_update(ExecutionPolicy&& exec, InVec1 x, InVec2 y, OutMat A, Triangle t);
7
#
These functions perform an overwriting symmetric rank-2 update of the symmetric matrix A, taking into account the Triangle parameter that applies to A ([linalg.general]).
8
#
Effects: Computes
🔗
template<in-vector InVec1, in-vector InVec2, in-matrix InMat, possibly-packed-out-matrix OutMat, class Triangle> void symmetric_matrix_rank_2_update(InVec1 x, InVec2 y, InMat E, OutMat A, Triangle t); template<class ExecutionPolicy, in-vector InVec1, in-vector InVec2, in-matrix InMat, possibly-packed-out-matrix OutMat, class Triangle> void symmetric_matrix_rank_2_update(ExecutionPolicy&& exec, InVec1 x, InVec2 y, InMat E, OutMat A, Triangle t);
9
#
These functions perform an updating symmetric rank-2 update of the symmetric matrix A using the symmetric matrix E, taking into account the Triangle parameter that applies to A and E ([linalg.general]).
10
#
Remarks: A may alias E.
🔗
template<in-vector InVec1, in-vector InVec2, possibly-packed-out-matrix OutMat, class Triangle> void hermitian_matrix_rank_2_update(InVec1 x, InVec2 y, OutMat A, Triangle t); template<class ExecutionPolicy, in-vector InVec1, in-vector InVec2, possibly-packed-out-matrix OutMat, class Triangle> void hermitian_matrix_rank_2_update(ExecutionPolicy&& exec, InVec1 x, InVec2 y, OutMat A, Triangle t);
12
#
These functions perform an overwriting Hermitian rank-2 update of the Hermitian matrix A, taking into account the Triangle parameter that applies to A ([linalg.general]).
13
#
Effects: Computes
🔗
template<in-vector InVec1, in-vector InVec2, in-matrix InMat, possibly-packed-out-matrix OutMat, class Triangle> void hermitian_matrix_rank_2_update(InVec1 x, InVec2 y, InMat E, OutMat A, Triangle t); template<class ExecutionPolicy, in-vector InVec1, in-vector InVec2, in-matrix InMat, possibly-packed-out-matrix OutMat, class Triangle> void hermitian_matrix_rank_2_update(ExecutionPolicy&& exec, InVec1 x, InVec2 y, InMat E, OutMat A, Triangle t);
14
#
These functions perform an updating Hermitian rank-2 update of the Hermitian matrix A using the Hermitian matrix E, taking into account the Triangle parameter that applies to A and E ([linalg.general]).
15
#
The following elements apply to all functions in [linalg.algs.blas3.gemm] in addition to function-specific elements.
3
#
Mandates: possibly-multipliable<decltype(A), decltype(B), decltype(C)>() is true.
4
#
Complexity:
🔗
template<in-matrix InMat1, in-matrix InMat2, out-matrix OutMat> void matrix_product(InMat1 A, InMat2 B, OutMat C); template<class ExecutionPolicy, in-matrix InMat1, in-matrix InMat2, out-matrix OutMat> void matrix_product(ExecutionPolicy&& exec, InMat1 A, InMat2 B, OutMat C);
6
#
Effects: Computes
🔗
template<in-matrix InMat1, in-matrix InMat2, in-matrix InMat3, out-matrix OutMat> void matrix_product(InMat1 A, InMat2 B, InMat3 E, OutMat C); template<class ExecutionPolicy, in-matrix InMat1, in-matrix InMat2, in-matrix InMat3, out-matrix OutMat> void matrix_product(ExecutionPolicy&& exec, InMat1 A, InMat2 B, InMat3 E, OutMat C);
7
#
Remarks: C may alias E.

29.9.15.2 Symmetric, Hermitian, and triangular matrix-matrix product [linalg.algs.blas3.xxmm]

1
#
[Note 1: 
These functions correspond to the BLAS functions xSYMM, xHEMM, and xTRMM[bib].
— end note]
2
#
The following elements apply to all functions in [linalg.algs.blas3.xxmm] in addition to function-specific elements.
3
#
Mandates:
  • (3.1)
    possibly-multipliable<decltype(A), decltype(B), decltype(C)>() is true, and
  • (3.2)
    possibly-addable<decltype(E), decltype(E), decltype(C)>() is true for those overloads that take an E parameter.
4
#
Preconditions:
  • (4.1)
    multipliable(A, B, C) is true, and
  • (4.2)
    addable(E, E, C) is true for those overloads that take an E parameter.
5
#
Complexity:
🔗
template<in-matrix InMat1, class Triangle, in-matrix InMat2, out-matrix OutMat> void symmetric_matrix_product(InMat1 A, Triangle t, InMat2 B, OutMat C); template<class ExecutionPolicy, in-matrix InMat1, class Triangle, in-matrix InMat2, out-matrix OutMat> void symmetric_matrix_product(ExecutionPolicy&& exec, InMat1 A, Triangle t, InMat2 B, OutMat C); template<in-matrix InMat1, class Triangle, in-matrix InMat2, out-matrix OutMat> void hermitian_matrix_product(InMat1 A, Triangle t, InMat2 B, OutMat C); template<class ExecutionPolicy, in-matrix InMat1, class Triangle, in-matrix InMat2, out-matrix OutMat> void hermitian_matrix_product(ExecutionPolicy&& exec, InMat1 A, Triangle t, InMat2 B, OutMat C); template<in-matrix InMat1, class Triangle, class DiagonalStorage, in-matrix InMat2, out-matrix OutMat> void triangular_matrix_product(InMat1 A, Triangle t, DiagonalStorage d, InMat2 B, OutMat C); template<class ExecutionPolicy, in-matrix InMat1, class Triangle, class DiagonalStorage, in-matrix InMat2, out-matrix OutMat> void triangular_matrix_product(ExecutionPolicy&& exec, InMat1 A, Triangle t, DiagonalStorage d, InMat2 B, OutMat C);
6
#
These functions perform a matrix-matrix multiply, taking into account the Triangle and DiagonalStorage (if applicable) parameters that apply to the symmetric, Hermitian, or triangular (respectively) matrix A ([linalg.general]).
7
#
Mandates:
  • (7.1)
    If InMat1 has layout_blas_packed layout, then the layout's Triangle template argument has the same type as the function's Triangle template argument; and
  • (7.2)
    compatible-static-extents<InMat1, InMat1>(0, 1) is true.
8
#
Effects: Computes
🔗
template<in-matrix InMat1, in-matrix InMat2, class Triangle, out-matrix OutMat> void symmetric_matrix_product(InMat1 A, InMat2 B, Triangle t, OutMat C); template<class ExecutionPolicy, in-matrix InMat1, in-matrix InMat2, class Triangle, out-matrix OutMat> void symmetric_matrix_product(ExecutionPolicy&& exec, InMat1 A, InMat2 B, Triangle t, OutMat C); template<in-matrix InMat1, in-matrix InMat2, class Triangle, out-matrix OutMat> void hermitian_matrix_product(InMat1 A, InMat2 B, Triangle t, OutMat C); template<class ExecutionPolicy, in-matrix InMat1, in-matrix InMat2, class Triangle, out-matrix OutMat> void hermitian_matrix_product(ExecutionPolicy&& exec, InMat1 A, InMat2 B, Triangle t, OutMat C); template<in-matrix InMat1, in-matrix InMat2, class Triangle, class DiagonalStorage, out-matrix OutMat> void triangular_matrix_product(InMat1 A, InMat2 B, Triangle t, DiagonalStorage d, OutMat C); template<class ExecutionPolicy, in-matrix InMat1, in-matrix InMat2, class Triangle, class DiagonalStorage, out-matrix OutMat> void triangular_matrix_product(ExecutionPolicy&& exec, InMat1 A, InMat2 B, Triangle t, DiagonalStorage d, OutMat C);
10
#
These functions perform a matrix-matrix multiply, taking into account the Triangle and DiagonalStorage (if applicable) parameters that apply to the symmetric, Hermitian, or triangular (respectively) matrix B ([linalg.general]).
11
#
Mandates:
  • (11.1)
    If InMat2 has layout_blas_packed layout, then the layout's Triangle template argument has the same type as the function's Triangle template argument; and
  • (11.2)
    compatible-static-extents<InMat2, InMat2>(0, 1) is true.
12
#
Effects: Computes
🔗
template<in-matrix InMat1, class Triangle, in-matrix InMat2, in-matrix InMat3, out-matrix OutMat> void symmetric_matrix_product(InMat1 A, Triangle t, InMat2 B, InMat3 E, OutMat C); template<class ExecutionPolicy, in-matrix InMat1, class Triangle, in-matrix InMat2, in-matrix InMat3, out-matrix OutMat> void symmetric_matrix_product(ExecutionPolicy&& exec, InMat1 A, Triangle t, InMat2 B, InMat3 E, OutMat C); template<in-matrix InMat1, class Triangle, in-matrix InMat2, in-matrix InMat3, out-matrix OutMat> void hermitian_matrix_product(InMat1 A, Triangle t, InMat2 B, InMat3 E, OutMat C); template<class ExecutionPolicy, in-matrix InMat1, class Triangle, in-matrix InMat2, in-matrix InMat3, out-matrix OutMat> void hermitian_matrix_product(ExecutionPolicy&& exec, InMat1 A, Triangle t, InMat2 B, InMat3 E, OutMat C); template<in-matrix InMat1, class Triangle, class DiagonalStorage, in-matrix InMat2, in-matrix InMat3, out-matrix OutMat> void triangular_matrix_product(InMat1 A, Triangle t, DiagonalStorage d, InMat2 B, InMat3 E, OutMat C); template<class ExecutionPolicy, in-matrix InMat1, class Triangle, class DiagonalStorage, in-matrix InMat2, in-matrix InMat3, out-matrix OutMat> void triangular_matrix_product(ExecutionPolicy&& exec, InMat1 A, Triangle t, DiagonalStorage d, InMat2 B, InMat3 E, OutMat C);
14
#
These functions perform a potentially overwriting matrix-matrix multiply-add, taking into account the Triangle and DiagonalStorage (if applicable) parameters that apply to the symmetric, Hermitian, or triangular (respectively) matrix A ([linalg.general]).
15
#
Mandates:
  • (15.1)
    If InMat1 has layout_blas_packed layout, then the layout's Triangle template argument has the same type as the function's Triangle template argument; and
  • (15.2)
    compatible-static-extents<InMat1, InMat1>(0, 1) is true.
16
#
Remarks: C may alias E.
🔗
template<in-matrix InMat1, in-matrix InMat2, class Triangle, in-matrix InMat3, out-matrix OutMat> void symmetric_matrix_product(InMat1 A, InMat2 B, Triangle t, InMat3 E, OutMat C); template<class ExecutionPolicy, in-matrix InMat1, in-matrix InMat2, class Triangle, in-matrix InMat3, out-matrix OutMat> void symmetric_matrix_product(ExecutionPolicy&& exec, InMat1 A, InMat2 B, Triangle t, InMat3 E, OutMat C); template<in-matrix InMat1, in-matrix InMat2, class Triangle, in-matrix InMat3, out-matrix OutMat> void hermitian_matrix_product(InMat1 A, InMat2 B, Triangle t, InMat3 E, OutMat C); template<class ExecutionPolicy, in-matrix InMat1, in-matrix InMat2, class Triangle, in-matrix InMat3, out-matrix OutMat> void hermitian_matrix_product(ExecutionPolicy&& exec, InMat1 A, InMat2 B, Triangle t, InMat3 E, OutMat C); template<in-matrix InMat1, in-matrix InMat2, class Triangle, class DiagonalStorage, in-matrix InMat3, out-matrix OutMat> void triangular_matrix_product(InMat1 A, InMat2 B, Triangle t, DiagonalStorage d, InMat3 E, OutMat C); template<class ExecutionPolicy, in-matrix InMat1, in-matrix InMat2, class Triangle, class DiagonalStorage, in-matrix InMat3, out-matrix OutMat> void triangular_matrix_product(ExecutionPolicy&& exec, InMat1 A, InMat2 B, Triangle t, DiagonalStorage d, InMat3 E, OutMat C);
19
#
These functions perform a potentially overwriting matrix-matrix multiply-add, taking into account the Triangle and DiagonalStorage (if applicable) parameters that apply to the symmetric, Hermitian, or triangular (respectively) matrix B ([linalg.general]).
20
#
Mandates:
  • (20.1)
    If InMat2 has layout_blas_packed layout, then the layout's Triangle template argument has the same type as the function's Triangle template argument; and
  • (20.2)
    compatible-static-extents<InMat2, InMat2>(0, 1) is true.
21
#
These functions perform an in-place matrix-matrix multiply, taking into account the Triangle and DiagonalStorage parameters that apply to the triangular matrix A ([linalg.general]).
[Note 1: 
These functions correspond to the BLAS function xTRMM[bib].
— end note]
🔗
template<in-matrix InMat, class Triangle, class DiagonalStorage, inout-matrix InOutMat> void triangular_matrix_left_product(InMat A, Triangle t, DiagonalStorage d, InOutMat C); template<class ExecutionPolicy, in-matrix InMat, class Triangle, class DiagonalStorage, inout-matrix InOutMat> void triangular_matrix_left_product(ExecutionPolicy&& exec, InMat A, Triangle t, DiagonalStorage d, InOutMat C);
2
#
Mandates:
  • (2.1)
    If InMat has layout_blas_packed layout, then the layout's Triangle template argument has the same type as the function's Triangle template argument;
  • (2.2)
    possibly-multipliable<InMat, InOutMat, InOutMat>() is true; and
  • (2.3)
    compatible-static-extents<InMat, InMat>(0, 1) is true.
3
#
Effects: Computes a matrix
5
#
Complexity:
🔗
template<in-matrix InMat, class Triangle, class DiagonalStorage, inout-matrix InOutMat> void triangular_matrix_right_product(InMat A, Triangle t, DiagonalStorage d, InOutMat C); template<class ExecutionPolicy, in-matrix InMat, class Triangle, class DiagonalStorage, inout-matrix InOutMat> void triangular_matrix_right_product(ExecutionPolicy&& exec, InMat A, Triangle t, DiagonalStorage d, InOutMat C);
6
#
Mandates:
  • (6.1)
    If InMat has layout_blas_packed layout, then the layout's Triangle template argument has the same type as the function's Triangle template argument;
  • (6.2)
    possibly-multipliable<InOutMat, InMat, InOutMat>() is true; and
  • (6.3)
    compatible-static-extents<InMat, InMat>(0, 1) is true.
7
#
Effects: Computes a matrix
9
#
[Note 1: 
These functions correspond to the BLAS functions xSYRK and xHERK[bib].
— end note]
2
#
For any function F in this subclause with a parameter named t, an InMat2 template parameter, and a function parameter InMat2 E, t applies to accesses done through the parameter E.
F only accesses the triangle of E specified by t.
For accesses of diagonal elements E[i, i], F only uses the value real-if-needed(E[i, i]) if the name of F starts with hermitian.
For accesses E[i, j] outside the triangle specified by t, F only uses the value
  • (3.1)
    conj-if-needed(E[j, i]) if the name of F starts with hermitian, or
  • (3.2)
    E[j, i] if the name of F starts with symmetric.
4
#
Mandates:
  • (4.1)
    If OutMat has layout_blas_packed layout, then the layout's Triangle template argument has the same type as the function's Triangle template argument;
  • (4.2)
    If the function has an InMat2 template parameter and if InMat2 has layout_blas_packed layout, then the layout's Triangle template argument has the same type as the function's Triangle template argument;
  • (4.3)
    possibly-multipliable<decltype(A), decltype(transposed(A)), decltype(C)>() is true; and
  • (4.4)
    possibly-addable<decltype(C), decltype(E), decltype(C)>() is true for those overloads with an E parameter.
5
#
Preconditions:
  • (5.1)
    multipliable(A, transposed(A), C) is true; and
    [Note 2: 
    This implies that C is square.
    — end note]
  • (5.2)
    addable(C, E, C) is true for those overloads with an E parameter.
6
#
Remarks: C may alias E for those overloads with an E parameter.
🔗
template<scalar Scalar, in-matrix InMat, possibly-packed-out-matrix OutMat, class Triangle> void symmetric_matrix_rank_k_update(Scalar alpha, InMat A, OutMat C, Triangle t); template<class ExecutionPolicy, scalar Scalar, in-matrix InMat, possibly-packed-out-matrix OutMat, class Triangle> void symmetric_matrix_rank_k_update(ExecutionPolicy&& exec, Scalar alpha, InMat A, OutMat C, Triangle t);
8
#
Effects: Computes
🔗
template<scalar Scalar, in-matrix InMat, possibly-packed-out-matrix OutMat, class Triangle> void hermitian_matrix_rank_k_update(Scalar alpha, InMat A, OutMat C, Triangle t); template<class ExecutionPolicy, scalar Scalar, in-matrix InMat, possibly-packed-out-matrix OutMat, class Triangle> void hermitian_matrix_rank_k_update(ExecutionPolicy&& exec, Scalar alpha, InMat A, OutMat C, Triangle t);
9
#
Effects: Computes
🔗
template<scalar Scalar, in-matrix InMat1, in-matrix InMat2, possibly-packed-out-matrix OutMat, class Triangle> void symmetric_matrix_rank_k_update(Scalar alpha, InMat1 A, InMat2 E, OutMat C, Triangle t); template<class ExecutionPolicy, scalar Scalar, in-matrix InMat1, in-matrix InMat2, possibly-packed-out-matrix OutMat, class Triangle> void symmetric_matrix_rank_k_update(ExecutionPolicy&& exec, Scalar alpha, InMat1 A, InMat2 E, OutMat C, Triangle t);
10
#
Effects: Computes
🔗
template<scalar Scalar, in-matrix InMat1, in-matrix InMat2, possibly-packed-out-matrix OutMat, class Triangle> void hermitian_matrix_rank_k_update(Scalar alpha, InMat1 A, InMat2 E, OutMat C, Triangle t); template<class ExecutionPolicy, scalar Scalar, in-matrix InMat1, in-matrix InMat2, possibly-packed-out-matrix OutMat, class Triangle> void hermitian_matrix_rank_k_update(ExecutionPolicy&& exec, Scalar alpha, InMat1 A, InMat2 E, OutMat C, Triangle t);
11
#
Effects: Computes

29.9.15.5 Rank-2k update of a symmetric or Hermitian matrix [linalg.algs.blas3.rank2k]

1
#
[Note 1: 
These functions correspond to the BLAS functions xSYR2K and xHER2K[bib].
— end note]
2
#
For any function F in this subclause with a parameter named t, an InMat3 template parameter, and a function parameter InMat3 E, t applies to accesses done through the parameter E.
F only accesses the triangle of E specified by t.
For accesses of diagonal elements E[i, i], F only uses the value real-if-needed(E[i, i]) if the name of F starts with hermitian.
For accesses E[i, j] outside the triangle specified by t, F only uses the value
  • (3.1)
    conj-if-needed(E[j, i]) if the name of F starts with hermitian, or
  • (3.2)
    E[j, i] if the name of F starts with symmetric.
4
#
Mandates:
  • (4.1)
    If OutMat has layout_blas_packed layout, then the layout's Triangle template argument has the same type as the function's Triangle template argument;
  • (4.2)
    If the function has an InMat3 template parameter and if InMat3 has layout_blas_packed layout, then the layout's Triangle template argument has the same type as the function's Triangle template argument;
  • (4.3)
    possibly-multipliable<decltype(A), decltype(transposed(B)), decltype(C)>() is true;
  • (4.4)
    possibly-multipliable<decltype(B), decltype(transposed(A)), decltype(C)>() is true; and
  • (4.5)
    possibly-addable<decltype(C), decltype(E), decltype(C)>() is true for those overloads with an E parameter.
5
#
Preconditions:
  • (5.1)
    multipliable(A, transposed(B), C) is true,
  • (5.2)
    multipliable(B, transposed(A), C) is true, and
    [Note 2: 
    This and the previous imply that C is square.
    — end note]
  • (5.3)
    addable(C, E, C) is true for those overloads with an E parameter.
6
#
Remarks: C may alias E for those overloads with an E parameter.
🔗
template<in-matrix InMat1, in-matrix InMat2, possibly-packed-out-matrix OutMat, class Triangle> void symmetric_matrix_rank_2k_update(InMat1 A, InMat2 B, OutMat C, Triangle t); template<class ExecutionPolicy, in-matrix InMat1, in-matrix InMat2, possibly-packed-out-matrix OutMat, class Triangle> void symmetric_matrix_rank_2k_update(ExecutionPolicy&& exec, InMat1 A, InMat2 B, OutMat C, Triangle t);
8
#
Effects: Computes
🔗
template<in-matrix InMat1, in-matrix InMat2, possibly-packed-out-matrix OutMat, class Triangle> void hermitian_matrix_rank_2k_update(InMat1 A, InMat2 B, OutMat C, Triangle t); template<class ExecutionPolicy, in-matrix InMat1, in-matrix InMat2, possibly-packed-out-matrix OutMat, class Triangle> void hermitian_matrix_rank_2k_update(ExecutionPolicy&& exec, InMat1 A, InMat2 B, OutMat C, Triangle t);
9
#
Effects: Computes
🔗
template<in-matrix InMat1, in-matrix InMat2, in-matrix InMat3, possibly-packed-out-matrix OutMat, class Triangle> void symmetric_matrix_rank_2k_update(InMat1 A, InMat2 B, InMat3 E, OutMat C, Triangle t); template<class ExecutionPolicy, in-matrix InMat1, in-matrix InMat2, in-matrix InMat3, possibly-packed-out-matrix OutMat, class Triangle> void symmetric_matrix_rank_2k_update(ExecutionPolicy&& exec, InMat1 A, InMat2 B, InMat3 E, OutMat C, Triangle t);
Computes
🔗
template<in-matrix InMat1, in-matrix InMat2, in-matrix InMat3, possibly-packed-out-matrix OutMat, class Triangle> void hermitian_matrix_rank_2k_update(InMat1 A, InMat2 B, InMat3 E, OutMat C, Triangle t); template<class ExecutionPolicy, in-matrix InMat1, in-matrix InMat2, in-matrix InMat3, possibly-packed-out-matrix OutMat, class Triangle> void hermitian_matrix_rank_2k_update(ExecutionPolicy&& exec, InMat1 A, InMat2 B, InMat3 E, OutMat C, Triangle t);
10
#
[Note 1: 
These functions correspond to the BLAS function xTRSM[bib].
— end note]
🔗
template<in-matrix InMat1, class Triangle, class DiagonalStorage, in-matrix InMat2, out-matrix OutMat, class BinaryDivideOp> void triangular_matrix_matrix_left_solve(InMat1 A, Triangle t, DiagonalStorage d, InMat2 B, OutMat X, BinaryDivideOp divide); template<class ExecutionPolicy, in-matrix InMat1, class Triangle, class DiagonalStorage, in-matrix InMat2, out-matrix OutMat, class BinaryDivideOp> void triangular_matrix_matrix_left_solve(ExecutionPolicy&& exec, InMat1 A, Triangle t, DiagonalStorage d, InMat2 B, OutMat X, BinaryDivideOp divide);
2
#
These functions perform multiple matrix solves, taking into account the Triangle and DiagonalStorage parameters that apply to the triangular matrix A ([linalg.general]).
3
#
Mandates:
  • (3.1)
    If InMat1 has layout_blas_packed layout, then the layout's Triangle template argument has the same type as the function's Triangle template argument;
  • (3.2)
    possibly-multipliable<InMat1, OutMat, InMat2>() is true; and
  • (3.3)
    compatible-static-extents<InMat1, InMat1>(0, 1) is true.
4
#
Effects: Computes
If no such
6
#
[Note 2: 
Since the triangular matrix is on the left, the desired divide implementation in the case of noncommutative multiplication is mathematically equivalent to
— end note]
🔗
template<in-matrix InMat1, class Triangle, class DiagonalStorage, in-matrix InMat2, out-matrix OutMat> void triangular_matrix_matrix_left_solve(InMat1 A, Triangle t, DiagonalStorage d, InMat2 B, OutMat X);
8
#
Effects: Equivalent to: triangular_matrix_matrix_left_solve(A, t, d, B, X, divides<void>{});
🔗
template<class ExecutionPolicy, in-matrix InMat1, class Triangle, class DiagonalStorage, in-matrix InMat2, out-matrix OutMat> void triangular_matrix_matrix_left_solve(ExecutionPolicy&& exec, InMat1 A, Triangle t, DiagonalStorage d, InMat2 B, OutMat X);
9
#
Effects: Equivalent to: triangular_matrix_matrix_left_solve(std::forward<ExecutionPolicy>(exec), A, t, d, B, X, divides<void>{});
🔗
template<in-matrix InMat1, class Triangle, class DiagonalStorage, in-matrix InMat2, out-matrix OutMat, class BinaryDivideOp> void triangular_matrix_matrix_right_solve(InMat1 A, Triangle t, DiagonalStorage d, InMat2 B, OutMat X, BinaryDivideOp divide); template<class ExecutionPolicy, in-matrix InMat1, class Triangle, class DiagonalStorage, in-matrix InMat2, out-matrix OutMat, class BinaryDivideOp> void triangular_matrix_matrix_right_solve(ExecutionPolicy&& exec, InMat1 A, Triangle t, DiagonalStorage d, InMat2 B, OutMat X, BinaryDivideOp divide);
10
#
These functions perform multiple matrix solves, taking into account the Triangle and DiagonalStorage parameters that apply to the triangular matrix A ([linalg.general]).
11
#
Mandates:
  • (11.1)
    If InMat1 has layout_blas_packed layout, then the layout's Triangle template argument has the same type as the function's Triangle template argument;
  • (11.2)
    possibly-multipliable<OutMat, InMat1, InMat2>() is true; and
  • (11.3)
    compatible-static-extents<InMat1, InMat1>(0,1) is true.
12
#
Effects: Computes
If no such
14
#
Complexity: O( B.extent(0)