Este archivo de encabezado es parte de la biblioteca numeric.
Clases | |
Definido en el espacio de nombres
std::linalg | |
(C++26) |
Política de mapeo de diseño a std::mdspan que representa una matriz cuadrada que almacena solo las entradas en un triángulo, en un formato contiguo empaquetado. (plantilla de clase) |
(C++26) |
Política de descriptor de acceso a std::mdspan cuya referencia representa el producto de un factor de escala que está fijo y su referencia a descriptor de acceso a std::mdspan anidada. (plantilla de clase) |
(C++26) |
Política de descriptor de acceso a std::mdspan cuya referencia representa el conjugado complejo de la referencia de su descriptor de acceso a std::mdspan anidado. (plantilla de clase) |
(C++26) |
Política de mapeo de diseño a std::mdspan que intercambia los dos índices más a la derecha, dimensiones y avances de cualquier política de mapeo de diseño única. (plantilla de clase) |
Etiquetas | |
Definido en el espacio de nombres
std::linalg | |
| Describe el orden de los elementos en un std::mdspan con un diseño linalg::layout_blas_packed. (tag) | |
| Especifica si los algoritmos y otros usuarios de una matriz deben acceder al triángulo superior o al triángulo inferior de la matriz. (tag) | |
| Especifica si los algoritmos deben acceder a las entradas diagonales de la matriz. (tag) | |
Funciones | |
Definido en el espacio de nombres
std::linalg | |
In-place transformations | |
(C++26) |
Devuelve un nuevo std::mdspan de solo lectura calculado por el producto por elementos del factor de escala y los elementos correspondientes del std::mdspan dado. (plantilla de función) |
(C++26) |
Devuelve un nuevo std::mdspan de solo lectura cuyos elementos son los conjugados complejos de los elementos correspondientes del std::mdspan dado. (plantilla de función) |
(C++26) |
Devuelve un std::mdspan nuevo que representa la transpuesta de la matriz de entrada por el std::mdspan dado . (plantilla de función) |
(C++26) |
Devuelve una vista transpuesta conjugada de un objeto. (plantilla de función) |
Funciones BLAS 1 | |
(C++26) |
Genera una rotación de plano. (plantilla de función) |
(C++26) |
Aplica rotación de plano a vectores. (plantilla de función) |
(C++26) |
Intercambia todos los miembros correspondientes de una matriz o un vector. (plantilla de función) |
(C++26) |
sobrescribe la matriz o el vector con el resultado de calcular la multiplicación de elemento por elemento por un escalar (plantilla de función) |
(C++26) |
Copia elementos de una matriz o vector en otra(o). (plantilla de función) |
(C++26) |
Agrega vectores o matrices elemento por elemento. (plantilla de función) |
(C++26) |
Devuelve el producto escalar no conjugado de dos vectores. (plantilla de función) |
(C++26) |
Devuelve el producto escalar conjugado de dos vectores. (plantilla de función) |
(C++26) |
Devuelve la suma escalada de cuadrados de los elementos del vector. (plantilla de función) |
(C++26) |
Devuelve la norma euclidiana de un vector. (plantilla de función) |
(C++26) |
Devuelve la suma de los valores absolutos de los elementos del vector. (plantilla de función) |
(C++26) |
Devuelve el índice del valor absoluto máximo de los elementos vectoriales. (plantilla de función) |
(C++26) |
Devuelve la norma de Frobenius de una matriz. (plantilla de función) |
(C++26) |
Devuelve una norma de una matriz. (plantilla de función) |
(C++26) |
Devuelve la norma de infinito de una matriz. (plantilla de función) |
Funciones BLAS 2 | |
(C++26) |
Calcula el producto matriz-vector. (plantilla de función) |
| Calcula el producto matriz-vector simétrica. (plantilla de función) | |
| Calcula el producto matriz-vector hermitiana. (plantilla de función) | |
| Calcula el producto matriz-vector triangular. (plantilla de función) | |
| Resuelve un sistema lineal triangular. (plantilla de función) | |
(C++26) |
Realiza una actualización no simétrica, no conjugada, y de rango 1 de una matriz. (plantilla de función) |
(C++26) |
Realiza una actualización no simétrica, conjugada, y de rango 1 de una matriz. (plantilla de función) |
| Realiza una actualización de rango 1 de una matriz simétrica. (plantilla de función) | |
| Realiza una actualización de una matriz hermitiana de rango 1. (plantilla de función) | |
| Realiza una actualización de rango 2 de una matriz simétrica. (plantilla de función) | |
| Realiza una actualización de rango 2 de una matriz hermitiana. (plantilla de función) | |
Funciones BLAS 3 | |
(C++26) |
Calcula el producto matriz-matriz. (plantilla de función) |
(C++26) |
Calcula el producto matriz-matriz simétrica. (plantilla de función) |
(C++26) |
Calcula el producto matriz-matriz hermitiana. (plantilla de función) |
| Calcula el producto triangular matriz-matriz. (plantilla de función) | |
| Realiza una actualización de rango k de una matriz simétrica. (plantilla de función) | |
| Realiza una actualización de rango k de una matriz hermitiana. (plantilla de función) | |
| Realiza una actualización de rango 2k de una matriz simétrica. (plantilla de función) | |
| Realiza una actualización de rango 2k de una matriz hermitiana. (plantilla de función) | |
| Resuelve múltiples sistemas lineales triangulares. (plantilla de función) | |
Sinopsis
namespace std::linalg {
// etiquetas de orden de almacenamiento
struct column_major_t;
inline constexpr column_major_t column_major;
struct row_major_t;
inline constexpr row_major_t row_major;
// etiquetas de triángulo
struct upper_triangle_t;
inline constexpr upper_triangle_t upper_triangle;
struct lower_triangle_t;
inline constexpr lower_triangle_t lower_triangle;
// etiquetas diagonales
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;
// plantilla de clase layout_blas_packed
template<class Triangle, class StorageOrder>
class layout_blas_packed;
// rasgos y conceptos de solo exposición
template<class T>
struct __is_mdspan; // solo exposición
template<class T>
concept __in_vector = /* véase descripción */; // solo exposición
template<class T>
concept __out_vector = /* véase descripción */; // solo exposición
template<class T>
concept __inout_vector = /* véase descripción */; // solo exposición
template<class T>
concept __in_matrix = /* véase descripción */; // solo exposición
template<class T>
concept __out_matrix = /* véase descripción */; // solo exposición
template<class T>
concept __inout_matrix = /* véase descripción */; // solo exposición
template<class T>
concept __possibly_packed_inout_matrix = /* véase descripción */; // solo exposición
template<class T>
concept __in_object = /* véase descripción */; // solo exposición
template<class T>
concept __out_object = /* véase descripción */; // solo exposición
template<class T>
concept __inout_object = /* véase descripción */; // solo exposición
// transformación in situ a escala
template<class ScalingFactor, class Accessor>
class scaled_accessor;
template<class ScalingFactor,
class ElementType, class Extents, class Layout, class Accessor>
constexpr auto scaled(ScalingFactor scaling_factor,
mdspan<ElementType, Extents, Layout, Accessor> x);
// transformación in situ conjugada
template<class Accessor>
class conjugated_accessor;
template<class ElementType, class Extents, class Layout, class Accessor>
constexpr auto conjugated(mdspan<ElementType, Extents, Layout, Accessor> a);
// transformación in situ transpuesta
template<class Layout>
class layout_transpose;
template<class ElementType, class Extents, class Layout, class Accessor>
constexpr auto transposed(mdspan<ElementType, Extents, Layout, Accessor> a);
// transformación in situ conjugada transpuesta
template<class ElementType, class Extents, class Layout, class Accessor>
constexpr auto conjugate_transposed(mdspan<ElementType, Extents, Layout, Accessor> a);
// algoritmos
// calcular rotación Givens
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;
// aplicar rotación Givens calculada
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);
// intercambiar elementos
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);
// multiplicar elementos por escalar
template<class Scalar, __inout_object InOutObj>
void scale(Scalar alpha, InOutObj x);
template<class ExecutionPolicy, class Scalar, __inout_object InOutObj>
void scale(ExecutionPolicy&& exec, Scalar alpha, InOutObj x);
// copiar elementos
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);
// agregar elemento por elemento
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);
// producto escalar no conjugado de dos vectores
template<__in_vector InVec1, __in_vector InVec2, class Scalar>
Scalar dot(InVec1 v1, InVec2 v2, Scalar init);
template<class ExecutionPolicy,
__in_vector InVec1, __in_vector InVec2, class Scalar>
Scalar dot(ExecutionPolicy&& exec, InVec1 v1, InVec2 v2, Scalar init);
template<__in_vector InVec1, __in_vector InVec2>
auto dot(InVec1 v1, InVec2 v2) -> /* véase descripción */;
template<class ExecutionPolicy, __in_vector InVec1, __in_vector InVec2>
auto dot(ExecutionPolicy&& exec, InVec1 v1, InVec2 v2) -> /* véase descripción */;
// producto escalar conjugado de dos vectores
template<__in_vector InVec1, __in_vector InVec2, class Scalar>
Scalar dotc(InVec1 v1, InVec2 v2, Scalar init);
template<class ExecutionPolicy,
__in_vector InVec1, __in_vector InVec2, class Scalar>
Scalar dotc(ExecutionPolicy&& exec, InVec1 v1, InVec2 v2, Scalar init);
template<__in_vector InVec1, __in_vector InVec2>
auto dotc(InVec1 v1, InVec2 v2) -> /* véase descripción */;
template<class ExecutionPolicy, __in_vector InVec1, __in_vector InVec2>
auto dotc(ExecutionPolicy&& exec, InVec1 v1, InVec2 v2) -> /* véase descripción */;
// suma escalada de cuadrados de los elementos de un vector
template<class Scalar>
struct sum_of_squares_result {
Scalar scaling_factor;
Scalar scaled_sum_of_squares;
};
template<__in_vector InVec, class Scalar>
sum_of_squares_result<Scalar>
vector_sum_of_squares(InVec v, sum_of_squares_result<Scalar> init);
template<class ExecutionPolicy, __in_vector InVec, class Scalar>
sum_of_squares_result<Scalar>
vector_sum_of_squares(ExecutionPolicy&& exec, InVec v,
sum_of_squares_result<Scalar> init);
// norma euclidiana de un vector
template<__in_vector InVec, class Scalar>
Scalar vector_two_norm(InVec v, Scalar init);
template<class ExecutionPolicy, __in_vector InVec, class Scalar>
Scalar vector_two_norm(ExecutionPolicy&& exec, InVec v, Scalar init);
template<__in_vector InVec>
auto vector_two_norm(InVec v) -> /* véase descripción */;
template<class ExecutionPolicy, __in_vector InVec>
auto vector_two_norm(ExecutionPolicy&& exec, InVec v) -> /* véase descripción */;
// suma de valores absolutos de elementos vectoriales
template<__in_vector InVec, class Scalar>
Scalar vector_abs_sum(InVec v, Scalar init);
template<class ExecutionPolicy, __in_vector InVec, class Scalar>
Scalar vector_abs_sum(ExecutionPolicy&& exec, InVec v, Scalar init);
template<__in_vector InVec>
auto vector_abs_sum(InVec v) -> /* véase descripción */;
template<class ExecutionPolicy, __in_vector InVec>
auto vector_abs_sum(ExecutionPolicy&& exec, InVec v) -> /* véase descripción */;
// índice del valor absoluto máximo de los elementos de un vector
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);
// norma de Frobenius de una matriz
template<__in_matrix InMat, class Scalar>
Scalar matrix_frob_norm(InMat A, Scalar init);
template<class ExecutionPolicy, __in_matrix InMat, class Scalar>
Scalar matrix_frob_norm(ExecutionPolicy&& exec,
InMat A, Scalar init);
template<__in_matrix InMat>
auto matrix_frob_norm(InMat A) -> /* véase descripción */;
template<class ExecutionPolicy, __in_matrix InMat>
auto matrix_frob_norm(ExecutionPolicy&& exec, InMat A) -> /* véase descripción */;
// una norma de una matriz
template<__in_matrix InMat, class Scalar>
Scalar matrix_one_norm(InMat A, Scalar init);
template<class ExecutionPolicy, __in_matrix InMat, class Scalar>
Scalar matrix_one_norm(ExecutionPolicy&& exec,
InMat A, Scalar init);
template<__in_matrix InMat>
auto matrix_one_norm(InMat A) -> /* véase descripción */;
template<class ExecutionPolicy, __in_matrix InMat>
auto matrix_one_norm(ExecutionPolicy&& exec, InMat A) -> /* véase descripción */;
// norma de infinidad de una matriz
template<__in_matrix InMat, class Scalar>
Scalar matrix_inf_norm(InMat A, Scalar init);
template<class ExecutionPolicy, __in_matrix InMat, class Scalar>
Scalar matrix_inf_norm(ExecutionPolicy&& exec,
InMat A, Scalar init);
template<__in_matrix InMat>
auto matrix_inf_norm(InMat A) -> /* véase descripción */;
template<class ExecutionPolicy, __in_matrix InMat>
auto matrix_inf_norm(ExecutionPolicy&& exec, InMat A) -> /* véase descripción */;
// producto matriz-vector general
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);
// producto matriz-vector simétrico
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);
// producto matriz-vector hermitiana
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);
// producto matriz-vector triangular
// 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);
// producto in situ matriz-vector triangular
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);
// actualizar producto matriz-vector triangular
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);
// resolver un sistema lineal triangular, no in situ
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);
// resolver un sistema lineal triangular, in situ
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);
// actualización de matriz de rango 1 no conjugada
template<__in_vector InVec1, __in_vector InVec2, __inout_matrix InOutMat>
void matrix_rank_1_update(InVec1 x, InVec2 y, InOutMat A);
template<class ExecutionPolicy,
__in_vector InVec1, __in_vector InVec2, __inout_matrix InOutMat>
void matrix_rank_1_update(ExecutionPolicy&& exec,
InVec1 x, InVec2 y, InOutMat A);
// actualización de matriz de rango 1 conjugada
template<__in_vector InVec1, __in_vector InVec2, __inout_matrix InOutMat>
void matrix_rank_1_update_c(InVec1 x, InVec2 y, InOutMat A);
template<class ExecutionPolicy,
__in_vector InVec1, __in_vector InVec2, __inout_matrix InOutMat>
void matrix_rank_1_update_c(ExecutionPolicy&& exec,
InVec1 x, InVec2 y, InOutMat A);
// actualización de matriz simétrica de rango 1
template<__in_vector InVec, __possibly_packed_inout_matrix InOutMat,
class Triangle>
void symmetric_matrix_rank_1_update(InVec x, InOutMat A, Triangle t);
template<class ExecutionPolicy,
__in_vector InVec, __possibly_packed_inout_matrix InOutMat,
class Triangle>
void symmetric_matrix_rank_1_update(ExecutionPolicy&& exec,
InVec x, InOutMat A, Triangle t);
template<class Scalar, __in_vector InVec,
__possibly_packed_inout_matrix InOutMat, class Triangle>
void symmetric_matrix_rank_1_update(Scalar alpha, InVec x, InOutMat A,
Triangle t);
template<class ExecutionPolicy,
class Scalar, __in_vector InVec,
__possibly_packed_inout_matrix InOutMat, class Triangle>
void symmetric_matrix_rank_1_update(ExecutionPolicy&& exec,
Scalar alpha, InVec x, InOutMat A,
Triangle t);
// actualización de la matriz hermitiana de rango 1
template<__in_vector InVec, __possibly_packed_inout_matrix InOutMat,
class Triangle>
void hermitian_matrix_rank_1_update(InVec x, InOutMat A, Triangle t);
template<class ExecutionPolicy,
__in_vector InVec, __possibly_packed_inout_matrix InOutMat,
class Triangle>
void hermitian_matrix_rank_1_update(ExecutionPolicy&& exec,
InVec x, InOutMat A, Triangle t);
template<class Scalar, __in_vector InVec,
__possibly_packed_inout_matrix InOutMat,
class Triangle>
void hermitian_matrix_rank_1_update(Scalar alpha, InVec x, InOutMat A,
Triangle t);
template<class ExecutionPolicy,
class Scalar, __in_vector InVec,
__possibly_packed_inout_matrix InOutMat,
class Triangle>
void hermitian_matrix_rank_1_update(ExecutionPolicy&& exec,
Scalar alpha, InVec x, InOutMat A,
Triangle t);
// actualización de matriz simétrica de rango 2
template<__in_vector InVec1, __in_vector InVec2,
__possibly_packed_inout_matrix InOutMat,
class Triangle>
void symmetric_matrix_rank_2_update(InVec1 x, InVec2 y, InOutMat A,
Triangle t);
template<class ExecutionPolicy,
__in_vector InVec1, __in_vector InVec2,
__possibly_packed_inout_matrix InOutMat,
class Triangle>
void symmetric_matrix_rank_2_update(ExecutionPolicy&& exec,
InVec1 x, InVec2 y, InOutMat A,
Triangle t);
// actualización de la matriz hermitiana de rango 2
template<__in_vector InVec1, __in_vector InVec2,
__possibly_packed_inout_matrix InOutMat,
class Triangle>
void hermitian_matrix_rank_2_update(InVec1 x, InVec2 y, InOutMat A,
Triangle t);
template<class ExecutionPolicy,
__in_vector InVec1, __in_vector InVec2,
__possibly_packed_inout_matrix InOutMat,
class Triangle>
void hermitian_matrix_rank_2_update(ExecutionPolicy&& exec,
InVec1 x, InVec2 y, InOutMat A,
Triangle t);
// producto general matriz-matriz
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);
// producto simétrico matriz-matriz
// sobrescribir el producto izquierdo matriz-matriz simétrica
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);
// sobrescribir el producto derecho matriz-matriz simétrica
template<__in_matrix InMat1, __in_matrix InMat2,
class Triangle, __out_matrix OutMat>
void symmetric_matrix_product(InMat1 B, InMat2 A, 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 B, InMat2 A, Triangle t,
OutMat C);
// actualizar el producto izquierdo matriz-matriz simétrica
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);
// actualizar el producto derecho matriz-matriz simétrica
template<__in_matrix InMat1, __in_matrix InMat2, class Triangle,
__in_matrix InMat3, __out_matrix OutMat>
void symmetric_matrix_product(InMat1 B, InMat2 A, 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 B, InMat2 A, Triangle t,
InMat3 E, OutMat C);
// producto matriz-matrix hermitiana
// sobreescribir el producto izquierdo matriz-matrix hermitiana
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);
// sobreescribir el producto derecho matriz-matrix hermitiana
template<__in_matrix InMat1, __in_matrix InMat2,
class Triangle, __out_matrix OutMat>
void hermitian_matrix_product(InMat1 B, InMat2 A, 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 B, InMat2 A, Triangle t,
OutMat C);
// actualizar el producto izquierdo matriz-matrix hermitiana
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);
// actualizar el producto derecho matriz-matrix hermitiana
template<__in_matrix InMat1, __in_matrix InMat2, class Triangle,
__in_matrix InMat3, __out_matrix OutMat>
void hermitian_matrix_product(InMat1 B, InMat2 A, 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 B, InMat2 A, Triangle t,
InMat3 E, OutMat C);
// producto triangular matriz-matriz
// sobreescribir el producto izquierdo triangular matriz-matriz
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, class Triangle, class DiagonalStorage,
__inout_matrix InOutMat>
void triangular_matrix_left_product(InMat1 A, Triangle t, DiagonalStorage d,
InOutMat C);
template<class ExecutionPolicy,
__in_matrix InMat1, class Triangle, class DiagonalStorage,
__inout_matrix InOutMat>
void triangular_matrix_left_product(ExecutionPolicy&& exec,
InMat1 A, Triangle t, DiagonalStorage d,
InOutMat C);
// sobreescribir el producto derecho triangular matriz-matriz
template<__in_matrix InMat1, __in_matrix InMat2,
class Triangle, class DiagonalStorage,
__out_matrix OutMat>
void triangular_matrix_product(InMat1 B, InMat2 A,
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 B, InMat2 A,
Triangle t, DiagonalStorage d,
OutMat C);
template<__in_matrix InMat1, class Triangle, class DiagonalStorage,
__inout_matrix InOutMat>
void triangular_matrix_right_product(InMat1 A, Triangle t, DiagonalStorage d,
InOutMat C);
template<class ExecutionPolicy,
__in_matrix InMat1, class Triangle, class DiagonalStorage,
__inout_matrix InOutMat>
void triangular_matrix_right_product(ExecutionPolicy&& exec,
InMat1 A, Triangle t, DiagonalStorage d,
InOutMat C);
// actualizar el producto izquierdo triangular matriz-matriz
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);
// actualizar el producto drecho triangular matriz-matriz
template<__in_matrix InMat1, __in_matrix InMat2,
class Triangle, class DiagonalStorage,
__in_matrix InMat3, __out_matrix OutMat>
void triangular_matrix_product(InMat1 B, InMat2 A,
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 B, InMat2 A,
Triangle t, DiagonalStorage d,
InMat3 E, OutMat C);
// actualizar matriz simétrica de rango k
template<class Scalar, __in_matrix InMat1,
__possibly_packed_inout_matrix InOutMat, class Triangle>
void symmetric_matrix_rank_k_update(Scalar alpha, InMat1 A, InOutMat C,
Triangle t);
template<class Scalar,
class ExecutionPolicy,
___in_matrix InMat1,
__possibly_packed_inout_matrix InOutMat, class Triangle>
void symmetric_matrix_rank_k_update(ExecutionPolicy&& exec,
Scalar alpha, InMat1 A, InOutMat C,
Triangle t);
template<__in_matrix InMat1,
__possibly_packed_inout_matrix InOutMat, class Triangle>
void symmetric_matrix_rank_k_update(InMat1 A, InOutMat C, Triangle t);
template<class ExecutionPolicy,
__in_matrix InMat1,
__possibly_packed_inout_matrix InOutMat, class Triangle>
void symmetric_matrix_rank_k_update(ExecutionPolicy&& exec,
InMat1 A, InOutMat C, Triangle t);
// actualizar matriz hermitiana de rango k
template<class Scalar, __in_matrix InMat1,
__possibly_packed_inout_matrix InOutMat, class Triangle>
void hermitian_matrix_rank_k_update(Scalar alpha, InMat1 A, InOutMat C,
Triangle t);
template<class ExecutionPolicy,
class Scalar, __in_matrix InMat1,
__possibly_packed_inout_matrix InOutMat, class Triangle
void hermitian_matrix_rank_k_update(ExecutionPolicy&& exec,
Scalar alpha, InMat1 A, InOutMat C,
Triangle t);
template<__in_matrix InMat1,
__possibly_packed_inout_matrix InOutMat, class Triangle>
void hermitian_matrix_rank_k_update(InMat1 A, InOutMat C, Triangle t);
template<class ExecutionPolicy,
__in_matrix InMat1,
__possibly_packed_inout_matrix InOutMat, class Triangle>
void hermitian_matrix_rank_k_update(ExecutionPolicy&& exec,
InMat1 A, InOutMat C, Triangle t);
// actualizar matriz simétrica de rango 2k
template<__in_matrix InMat1, __in_matrix InMat2,
__possibly_packed_inout_matrix InOutMat, class Triangle>
void symmetric_matrix_rank_2k_update(InMat1 A, InMat2 B, InOutMat C,
Triangle t);
template<class ExecutionPolicy,
__in_matrix InMat1, __in_matrix InMat2,
__possibly_packed_inout_matrix InOutMat, class Triangle>
void symmetric_matrix_rank_2k_update(ExecutionPolicy&& exec,
InMat1 A, InMat2 B, InOutMat C,
Triangle t);
// actualizar matriz hermitiana de rango 2k
template<__in_matrix InMat1, __in_matrix InMat2,
__possibly_packed_inout_matrix InOutMat, class Triangle>
void hermitian_matrix_rank_2k_update(InMat1 A, InMat2 B, InOutMat C,
Triangle t);
template<class ExecutionPolicy,
__in_matrix InMat1, __in_matrix InMat2,
__possibly_packed_inout_matrix InOutMat, class Triangle>
void hermitian_matrix_rank_2k_update(ExecutionPolicy&& exec,
InMat1 A, InMat2 B, InOutMat C,
Triangle t);
// resolver múltiples sistemas lineales triangulares
// con matriz triangular a la izquierda
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,
__inout_matrix InOutMat, class BinaryDivideOp>
void triangular_matrix_matrix_left_solve(InMat1 A, Triangle t, DiagonalStorage d,
InOutMat B, BinaryDivideOp divide);
template<class ExecutionPolicy,
__in_matrix InMat1, class Triangle, class DiagonalStorage,
__inout_matrix InOutMat, class BinaryDivideOp>
void triangular_matrix_matrix_left_solve(ExecutionPolicy&& exec,
InMat1 A, Triangle t, DiagonalStorage d,
InOutMat B, 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);
template<__in_matrix InMat1, class Triangle, class DiagonalStorage,
__inout_matrix InOutMat>
void triangular_matrix_matrix_left_solve(InMat1 A, Triangle t, DiagonalStorage d,
InOutMat B);
template<class ExecutionPolicy,
__in_matrix InMat1, class Triangle, class DiagonalStorage,
__inout_matrix InOutMat>
void triangular_matrix_matrix_left_solve(ExecutionPolicy&& exec,
InMat1 A, Triangle t, DiagonalStorage d,
InOutMat B);
// resolver múltiples sistemas lineales triangulares
// con matriz triangular a la derecha
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,
__inout_matrix InOutMat, class BinaryDivideOp>
void triangular_matrix_matrix_right_solve(InMat1 A, Triangle t, DiagonalStorage d,
InOutMat B, BinaryDivideOp divide);
template<class ExecutionPolicy,
__in_matrix InMat1, class Triangle, class DiagonalStorage,
__inout_matrix InOutMat, class BinaryDivideOp>
void triangular_matrix_matrix_right_solve(ExecutionPolicy&& exec,
InMat1 A, Triangle t, DiagonalStorage d,
InOutMat B, 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);
template<__in_matrix InMat1, class Triangle, class DiagonalStorage,
__inout_matrix InOutMat>
void triangular_matrix_matrix_right_solve(InMat1 A, Triangle t, DiagonalStorage d,
InOutMat B);
template<class ExecutionPolicy,
__in_matrix InMat1, class Triangle, class DiagonalStorage,
__inout_matrix InOutMat>
void triangular_matrix_matrix_right_solve(ExecutionPolicy&& exec,
InMat1 A, Triangle t, DiagonalStorage d,
InOutMat B);
}
Etiquetas
namespace std::linalg {
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 = { };
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 = { };
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 = { };
}
Plantilla de clase std::linalg::layout_blas_packed
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 = typename extents_type::index_type;
using size_type = typename extents_type::size_type;
using rank_type = typename extents_type::rank_type;
using layout_type = layout_blas_packed<Triangle, StorageOrder>;
private:
Extents __the_extents{}; // solo exposición
public:
constexpr mapping() noexcept = default;
constexpr mapping(const mapping&) noexcept = default;
constexpr mapping(const extents_type& e) 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;
constexpr extents_type extents() const noexcept { return __the_extents; }
constexpr size_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() {
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() { return true; }
static constexpr bool is_always_strided() {
return is_always_unique();
}
constexpr bool is_unique() const noexcept {
return __the_extents.extent(0) < 2;
}
constexpr bool is_exhaustive() const noexcept { return true; }
constexpr bool is_strided() const noexcept {
return __the_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;
};
};
}
Plantilla de clase std::linalg::scaled_accessor
namespace std::linalg {
template<class ScalingFactor, class NestedAccessor>
class scaled_accessor {
public:
using element_type =
add_const_t<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>&);
constexpr scaled_accessor(const ScalingFactor& s, const Accessor& a);
constexpr reference access(data_handle_type p, size_t i) const noexcept;
constexpr
offset_policy::data_handle_type offset(data_handle_type p, size_t i) const noexcept;
constexpr const ScalingFactor& scaling_factor() const noexcept
{ return __scaling_factor; }
constexpr const NestedAccessor& nested_accessor() const noexcept
{ return __nested_accessor; }
private:
ScalingFactor __scaling_factor; // solo exposición
NestedAccessor __nested_accessor; // solo exposición
};
}
Plantilla de clase std::linalg::conjugated_accessor
namespace std::linalg {
template<class NestedAccessor>
class conjugated_accessor {
private:
NestedAccessor __nested_accessor; // solo exposición
public:
using element_type =
add_const_t<decltype(/*conj-if-needed*/(declval<NestedAccessor::element_type>()))>;
using reference = remove_const_t<element_type>;
using data_handle_type = typename NestedAccessor::data_handle_type;
using offset_policy = conjugated_accessor<NestedAccessor::offset_policy>;
constexpr conjugated_accessor() = default;
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; }
};
}
Plantilla de clase std::linalg::layout_transpose
namespace std::linalg {
template<class InputExtents>
using __transpose_extents_t = /* véase descripción */; // solo exposición
template<class Layout>
class layout_transpose {
public:
using nested_layout_type = Layout;
template<class Extents>
struct mapping {
private:
using __nested_mapping_type =
typename Layout::template mapping<
__transpose_extents_t<Extents>>; // solo exposición
__nested_mapping_type __nested_mapping; // solo exposición
extents_type __extents; // solo exposición
public:
using extents_type = Extents;
using index_type = typename extents_type::index_type;
using size_type = typename extents_type::size_type;
using rank_type = typename extents_type::rank_type;
using layout_type = layout_transpose;
constexpr explicit mapping(const __nested_mapping_type& map);
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);
};
};
}
Conceptos y rasgos auxiliares
namespace std::linalg {
template<class T>
struct __is_mdspan : false_type {}; // solo exposición
template<class ElementType, class Extents, class Layout, class Accessor>
struct __is_mdspan<mdspan<ElementType, Extents, Layout, Accessor>>
: true_type {}; // solo exposición
template<class T>
concept __in_vector = // solo exposición
__is_mdspan<T>::value &&
T::rank() == 1;
template<class T>
concept __out_vector = // solo exposición
__is_mdspan<T>::value &&
T::rank() == 1 &&
is_assignable_v<typename T::reference, typename T::element_type> &&
T::is_always_unique();
template<class T>
concept __inout_vector = // solo exposición
__is_mdspan<T>::value &&
T::rank() == 1 &&
is_assignable_v<typename T::reference, typename T::element_type> &&
T::is_always_unique();
template<class T>
concept __in_matrix = // solo exposición
__is_mdspan<T>::value &&
T::rank() == 2;
template<class T>
concept __out_matrix = // solo exposición
__is_mdspan<T>::value &&
T::rank() == 2 &&
is_assignable_v<typename T::reference, typename T::element_type> &&
T::is_always_unique();
template<class T>
concept __inout_matrix = // solo exposición
__is_mdspan<T>::value &&
T::rank() == 2 &&
is_assignable_v<typename T::reference, typename T::element_type> &&
T::is_always_unique();
template<class T>
concept __possibly_packed_inout_matrix = // solo exposición
__is_mdspan<T>::value &&
T::rank() == 2 &&
is_assignable_v<typename T::reference, typename T::element_type> &&
(T::is_always_unique() || is_same_v<typename T::layout_type, layout_blas_packed>);
template<class T>
concept __in_object = // solo exposición
__is_mdspan<T>::value &&
(T::rank() == 1 || T::rank() == 2);
template<class T>
concept __out_object = // solo exposición
__is_mdspan<T>::value &&
(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 = // solo exposición
__is_mdspan<T>::value &&
(T::rank() == 1 || T::rank() == 2) &&
is_assignable_v<typename T::reference, typename T::element_type> &&
T::is_always_unique();
}