stdlib_linalg 模块

提供对各种线性代数过程的支持 (规范)


使用

被…使用


接口

公共接口 chol

计算 Cholesky 分解，或。 (规范)

摘要

用于计算 Cholesky 三角因子的纯函数接口。

描述

此接口提供计算 Cholesky 分解的实对称或复埃尔米特矩阵的下三角或上三角矩阵的方法。支持的数据类型包括real和complex。

注意

该解决方案基于 LAPACK 的*POTRF方法。

  • 私有纯模块函数 stdlib_linalg_c_cholesky_fun(a, lower, other_zeroed) 结果(c)

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(in) :: a(:,:)

    输入矩阵 a[m,n]
    logical(kind=lk), intent(in), optional :: lower

    [可选] 是否需要下三角或上三角因子？默认值 = 下三角
    logical(kind=lk), intent(in), optional :: other_zeroed

    [可选] 是否应将返回矩阵的未使用部分清零？默认值：是

    返回值 complex(kind=sp), (size(a,1),size(a,2))

    包含 Cholesky 因子的输出矩阵 c[n,n]

  • 私有纯模块函数 stdlib_linalg_d_cholesky_fun(a, lower, other_zeroed) 结果(c)

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(in) :: a(:,:)

    输入矩阵 a[m,n]
    logical(kind=lk), intent(in), optional :: lower

    [可选] 是否需要下三角或上三角因子？默认值 = 下三角
    logical(kind=lk), intent(in), optional :: other_zeroed

    [可选] 是否应将返回矩阵的未使用部分清零？默认值：是

    返回值 real(kind=dp), (size(a,1),size(a,2))

    包含 Cholesky 因子的输出矩阵 c[n,n]

  • 私有纯模块函数 stdlib_linalg_s_cholesky_fun(a, lower, other_zeroed) 结果(c)

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(in) :: a(:,:)

    输入矩阵 a[m,n]
    logical(kind=lk), intent(in), optional :: lower

    [可选] 是否需要下三角或上三角因子？默认值 = 下三角
    logical(kind=lk), intent(in), optional :: other_zeroed

    [可选] 是否应将返回矩阵的未使用部分清零？默认值：是

    返回值 real(kind=sp), (size(a,1),size(a,2))

    包含 Cholesky 因子的输出矩阵 c[n,n]

  • 私有纯模块函数 stdlib_linalg_z_cholesky_fun(a, lower, other_zeroed) 结果(c)

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(in) :: a(:,:)

    输入矩阵 a[m,n]
    logical(kind=lk), intent(in), optional :: lower

    [可选] 是否需要下三角或上三角因子？默认值 = 下三角
    logical(kind=lk), intent(in), optional :: other_zeroed

    [可选] 是否应将返回矩阵的未使用部分清零？默认值：是

    返回值 complex(kind=dp), (size(a,1),size(a,2))

    包含 Cholesky 因子的输出矩阵 c[n,n]

公共接口 cholesky

计算 Cholesky 分解，或。 (规范)

摘要

用于计算 Cholesky 三角因子的纯子程序接口。

描述

此接口提供计算 Cholesky 分解的实对称或复埃尔米特矩阵的下三角或上三角矩阵的方法。支持的数据类型包括real和complex。
如果只有一个矩阵参数，则原位计算分解；如果存在，则返回到第二个矩阵参数。lower logical 标志允许在上下分解之间进行选择；other_zeroed 可选 logical 标志允许选择是否应将三角矩阵的未使用部分填充为零。

注意

该解决方案基于 LAPACK 的*POTRF方法。

  • 私有纯模块子程序 stdlib_linalg_c_cholesky(a, c, lower, other_zeroed, err)

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(in) :: a(:,:)

    输入矩阵 a[n,n]
    complex(kind=sp), intent(out) :: c(:,:)

    包含 Cholesky 因子的输出矩阵 c[n,n]
    logical(kind=lk), intent(in), optional :: lower

    [可选] 是否需要下三角或上三角因子？默认值 = 下三角
    logical(kind=lk), intent(in), optional :: other_zeroed

    [可选] 是否应将返回矩阵的未使用部分清零？默认值：是
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • 私有纯模块子程序 stdlib_linalg_c_cholesky_inplace(a, lower, other_zeroed, err)

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(inout), target :: a(:,:)

    输入矩阵 a[m,n]
    logical(kind=lk), intent(in), optional :: lower

    [可选] 是否需要下三角或上三角因子？默认值 = 下三角
    logical(kind=lk), intent(in), optional :: other_zeroed

    [可选] 是否应将返回矩阵的未使用部分清零？默认值：是
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • 私有纯模块子程序 stdlib_linalg_d_cholesky(a, c, lower, other_zeroed, err)

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(in) :: a(:,:)

    输入矩阵 a[n,n]
    real(kind=dp), intent(out) :: c(:,:)

    包含 Cholesky 因子的输出矩阵 c[n,n]
    logical(kind=lk), intent(in), optional :: lower

    [可选] 是否需要下三角或上三角因子？默认值 = 下三角
    logical(kind=lk), intent(in), optional :: other_zeroed

    [可选] 是否应将返回矩阵的未使用部分清零？默认值：是
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • 私有纯模块子程序 stdlib_linalg_d_cholesky_inplace(a, lower, other_zeroed, err)

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(inout), target :: a(:,:)

    输入矩阵 a[m,n]
    logical(kind=lk), intent(in), optional :: lower

    [可选] 是否需要下三角或上三角因子？默认值 = 下三角
    logical(kind=lk), intent(in), optional :: other_zeroed

    [可选] 是否应将返回矩阵的未使用部分清零？默认值：是
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • 私有纯模块子程序 stdlib_linalg_s_cholesky(a, c, lower, other_zeroed, err)

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(in) :: a(:,:)

    输入矩阵 a[n,n]
    real(kind=sp), intent(out) :: c(:,:)

    包含 Cholesky 因子的输出矩阵 c[n,n]
    logical(kind=lk), intent(in), optional :: lower

    [可选] 是否需要下三角或上三角因子？默认值 = 下三角
    logical(kind=lk), intent(in), optional :: other_zeroed

    [可选] 是否应将返回矩阵的未使用部分清零？默认值：是
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • 私有纯模块子程序 stdlib_linalg_s_cholesky_inplace(a, lower, other_zeroed, err)

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(inout), target :: a(:,:)

    输入矩阵 a[m,n]
    logical(kind=lk), intent(in), optional :: lower

    [可选] 是否需要下三角或上三角因子？默认值 = 下三角
    logical(kind=lk), intent(in), optional :: other_zeroed

    [可选] 是否应将返回矩阵的未使用部分清零？默认值：是
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • 私有纯模块子程序 stdlib_linalg_z_cholesky(a, c, lower, other_zeroed, err)

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(in) :: a(:,:)

    输入矩阵 a[n,n]
    complex(kind=dp), intent(out) :: c(:,:)

    包含 Cholesky 因子的输出矩阵 c[n,n]
    logical(kind=lk), intent(in), optional :: lower

    [可选] 是否需要下三角或上三角因子？默认值 = 下三角
    logical(kind=lk), intent(in), optional :: other_zeroed

    [可选] 是否应将返回矩阵的未使用部分清零？默认值：是
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • 私有纯模块子程序 stdlib_linalg_z_cholesky_inplace(a, lower, other_zeroed, err)

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(inout), target :: a(:,:)

    输入矩阵 a[m,n]
    logical(kind=lk), intent(in), optional :: lower

    [可选] 是否需要下三角或上三角因子？默认值 = 下三角
    logical(kind=lk), intent(in), optional :: other_zeroed

    [可选] 是否应将返回矩阵的未使用部分清零？默认值：是
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

公共接口 cross_product

计算两个向量的叉积，返回一个秩为 1 且大小为 3 的数组 (规范)

  • 私有纯模块函数 cross_product_cdp(a, b) 结果(res)

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(in) :: a(3)
    complex(kind=dp), intent(in) :: b(3)

    返回值 complex(kind=dp), (3)

  • 私有纯模块函数 cross_product_csp(a, b) 结果(res)

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(in) :: a(3)
    complex(kind=sp), intent(in) :: b(3)

    返回值 complex(kind=sp), (3)

  • 私有纯模块函数 cross_product_iint16(a, b) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int16), intent(in) :: a(3)
    integer(kind=int16), intent(in) :: b(3)

    返回值 integer(kind=int16), (3)

  • 私有纯模块函数 cross_product_iint32(a, b) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int32), intent(in) :: a(3)
    integer(kind=int32), intent(in) :: b(3)

    返回值 integer(kind=int32), (3)

  • 私有纯模块函数 cross_product_iint64(a, b) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int64), intent(in) :: a(3)
    integer(kind=int64), intent(in) :: b(3)

    返回值 integer(kind=int64), (3)

  • 私有纯模块函数 cross_product_iint8(a, b) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int8), intent(in) :: a(3)
    integer(kind=int8), intent(in) :: b(3)

    返回值 integer(kind=int8), (3)

  • 私有纯模块函数 cross_product_rdp(a, b) 结果(res)

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(in) :: a(3)
    real(kind=dp), intent(in) :: b(3)

    返回值 real(kind=dp), (3)

  • 私有纯模块函数 cross_product_rsp(a, b) 结果(res)

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(in) :: a(3)
    real(kind=sp), intent(in) :: b(3)

    返回值 real(kind=sp), (3)

公共接口 det

计算方阵的行列式 (规范)

摘要

用于计算矩阵行列式的接口。

描述

此接口提供计算矩阵行列式的方法。支持的数据类型包括real和complex。

注意

提供的函数仅适用于方阵。

注意

BLAS/LAPACK 后端目前不支持扩展精度 (xdp)。

示例

    real(sp) :: a(3,3), d
    type(linalg_state_type) :: state  
    a = reshape([1, 2, 3, 4, 5, 6, 7, 8, 9], [3, 3])

    ! ...
    d = det(a,err=state)
    if (state%ok()) then 
       print *, 'Success! det=',d
    else
       print *, state%print()
    endif
    ! ...

  • 私有接口 stdlib_linalg_rspdeterminant()

    参数

    无

  • 私有接口 stdlib_linalg_pure_rspdeterminant()

    参数

    无

  • 私有接口 stdlib_linalg_rdpdeterminant()

    参数

    无

  • 私有接口 stdlib_linalg_pure_rdpdeterminant()

    参数

    无

  • 私有接口 stdlib_linalg_cspdeterminant()

    参数

    无

  • 私有接口 stdlib_linalg_pure_cspdeterminant()

    参数

    无

  • 私有接口 stdlib_linalg_cdpdeterminant()

    参数

    无

  • 私有接口 stdlib_linalg_pure_cdpdeterminant()

    参数

    无

公共接口 diag

创建对角线数组或提取数组的对角线元素（规范）

  • 私有模块函数 diag_cdp(v) 结果(res)

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(in) :: v(:)

    返回值 complex(kind=dp), (size(v),size(v))

  • 私有模块函数 diag_cdp_k(v, k) 结果(res)

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(in) :: v(:)
    integer, intent(in) :: k

    返回值 complex(kind=dp), (size(v)+abs(k),size(v)+abs(k))

  • 私有模块函数 diag_cdp_mat(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(in) :: A(:,:)

    返回值 complex(kind=dp), (minval(shape(A)))

  • 私有模块函数 diag_cdp_mat_k(A, k) 结果(res)

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(in) :: A(:,:)
    integer, intent(in) :: k

    返回值 complex(kind=dp), (minval(shape(A))-abs(k))

  • 私有模块函数 diag_csp(v) 结果(res)

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(in) :: v(:)

    返回值 complex(kind=sp), (size(v),size(v))

  • 私有模块函数 diag_csp_k(v, k) 结果(res)

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(in) :: v(:)
    integer, intent(in) :: k

    返回值 complex(kind=sp), (size(v)+abs(k),size(v)+abs(k))

  • 私有模块函数 diag_csp_mat(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(in) :: A(:,:)

    返回值 complex(kind=sp), (minval(shape(A)))

  • 私有模块函数 diag_csp_mat_k(A, k) 结果(res)

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(in) :: A(:,:)
    integer, intent(in) :: k

    返回值 complex(kind=sp), (minval(shape(A))-abs(k))

  • 私有模块函数 diag_iint16(v) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int16), intent(in) :: v(:)

    返回值 integer(kind=int16), (size(v),size(v))

  • 私有模块函数 diag_iint16_k(v, k) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int16), intent(in) :: v(:)
    integer, intent(in) :: k

    返回值 integer(kind=int16), (size(v)+abs(k),size(v)+abs(k))

  • 私有模块函数 diag_iint16_mat(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int16), intent(in) :: A(:,:)

    返回值 integer(kind=int16), (minval(shape(A)))

  • 私有模块函数 diag_iint16_mat_k(A, k) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int16), intent(in) :: A(:,:)
    integer, intent(in) :: k

    返回值 integer(kind=int16), (minval(shape(A))-abs(k))

  • 私有模块函数 diag_iint32(v) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int32), intent(in) :: v(:)

    返回值 integer(kind=int32), (size(v),size(v))

  • 私有模块函数 diag_iint32_k(v, k) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int32), intent(in) :: v(:)
    integer, intent(in) :: k

    返回值 integer(kind=int32), (size(v)+abs(k),size(v)+abs(k))

  • 私有模块函数 diag_iint32_mat(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int32), intent(in) :: A(:,:)

    返回值 integer(kind=int32), (minval(shape(A)))

  • 私有模块函数 diag_iint32_mat_k(A, k) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int32), intent(in) :: A(:,:)
    integer, intent(in) :: k

    返回值 integer(kind=int32), (minval(shape(A))-abs(k))

  • 私有模块函数 diag_iint64(v) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int64), intent(in) :: v(:)

    返回值 integer(kind=int64), (size(v),size(v))

  • 私有模块函数 diag_iint64_k(v, k) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int64), intent(in) :: v(:)
    integer, intent(in) :: k

    返回值 integer(kind=int64), (size(v)+abs(k),size(v)+abs(k))

  • 私有模块函数 diag_iint64_mat(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int64), intent(in) :: A(:,:)

    返回值 integer(kind=int64), (minval(shape(A)))

  • 私有模块函数 diag_iint64_mat_k(A, k) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int64), intent(in) :: A(:,:)
    integer, intent(in) :: k

    返回值 integer(kind=int64), (minval(shape(A))-abs(k))

  • 私有模块函数 diag_iint8(v) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int8), intent(in) :: v(:)

    返回值 integer(kind=int8), (size(v),size(v))

  • 私有模块函数 diag_iint8_k(v, k) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int8), intent(in) :: v(:)
    integer, intent(in) :: k

    返回值 integer(kind=int8), (size(v)+abs(k),size(v)+abs(k))

  • 私有模块函数 diag_iint8_mat(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int8), intent(in) :: A(:,:)

    返回值 integer(kind=int8), (minval(shape(A)))

  • 私有模块函数 diag_iint8_mat_k(A, k) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int8), intent(in) :: A(:,:)
    integer, intent(in) :: k

    返回值 integer(kind=int8), (minval(shape(A))-abs(k))

  • 私有模块函数 diag_rdp(v) 结果(res)

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(in) :: v(:)

    返回值 real(kind=dp), (size(v),size(v))

  • 私有模块函数 diag_rdp_k(v, k) 结果(res)

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(in) :: v(:)
    integer, intent(in) :: k

    返回值 real(kind=dp), (size(v)+abs(k),size(v)+abs(k))

  • 私有模块函数 diag_rdp_mat(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(in) :: A(:,:)

    返回值 real(kind=dp), (minval(shape(A)))

  • 私有模块函数 diag_rdp_mat_k(A, k) 结果(res)

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(in) :: A(:,:)
    integer, intent(in) :: k

    返回值 real(kind=dp), (minval(shape(A))-abs(k))

  • 私有模块函数 diag_rsp(v) 结果(res)

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(in) :: v(:)

    返回值 real(kind=sp), (size(v),size(v))

  • 私有模块函数 diag_rsp_k(v, k) 结果(res)

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(in) :: v(:)
    integer, intent(in) :: k

    返回值 real(kind=sp), (size(v)+abs(k),size(v)+abs(k))

  • 私有模块函数 diag_rsp_mat(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(in) :: A(:,:)

    返回值 real(kind=sp), (minval(shape(A)))

  • 私有模块函数 diag_rsp_mat_k(A, k) 结果(res)

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(in) :: A(:,:)
    integer, intent(in) :: k

    返回值 real(kind=sp), (minval(shape(A))-abs(k))

公共接口 eig

求解特征分解用于方阵。(规范）

摘要

计算方阵特征值和特征向量的子程序接口。

描述

此接口提供计算一般方阵的特征值以及可选的特征向量的方法。支持的数据类型包括real和complex，并且不对矩阵结构做任何假设。用户可以请求返回左特征向量、右特征向量或两者。它们作为与A大小相同的方阵的列返回。特征值lambda和特征向量矩阵都需要用户预先分配空间。

注意

该解决方案基于 LAPACK 的通用特征问题求解器*GEEV。

注意

BLAS/LAPACK 后端目前不支持扩展精度 (xdp)。

  • 私有模块子程序 stdlib_linalg_eig_c(a, lambda, right, left, overwrite_a, err)

    矩阵 A 的特征分解，返回一个包含特征值的数组lambda，以及可选的右或左特征向量。

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(inout), target :: a(:,:)

    输入矩阵 A[m,n]
    complex(kind=sp), intent(out) :: lambda(:)

    特征值数组
    complex(kind=sp), intent(out), 可选的， target :: right(:,:)

    RIGHT 的列包含 A 的右特征向量
    complex(kind=sp), intent(out), 可选的， target :: left(:,:)

    LEFT 的列包含 A 的左特征向量
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] 可以覆盖和销毁 A 数据吗？
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • 私有模块子程序 stdlib_linalg_eig_d(a, lambda, right, left, overwrite_a, err)

    矩阵 A 的特征分解，返回一个包含特征值的数组lambda，以及可选的右或左特征向量。

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(inout), target :: a(:,:)

    输入矩阵 A[m,n]
    complex(kind=dp), intent(out) :: lambda(:)

    特征值数组
    complex(kind=dp), intent(out), 可选的， target :: right(:,:)

    RIGHT 的列包含 A 的右特征向量
    complex(kind=dp), intent(out), 可选的， target :: left(:,:)

    LEFT 的列包含 A 的左特征向量
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] 可以覆盖和销毁 A 数据吗？
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • 私有模块子程序 stdlib_linalg_eig_s(a, lambda, right, left, overwrite_a, err)

    矩阵 A 的特征分解，返回一个包含特征值的数组lambda，以及可选的右或左特征向量。

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(inout), target :: a(:,:)

    输入矩阵 A[m,n]
    complex(kind=sp), intent(out) :: lambda(:)

    特征值数组
    complex(kind=sp), intent(out), 可选的， target :: right(:,:)

    RIGHT 的列包含 A 的右特征向量
    complex(kind=sp), intent(out), 可选的， target :: left(:,:)

    LEFT 的列包含 A 的左特征向量
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] 可以覆盖和销毁 A 数据吗？
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • 私有模块子程序 stdlib_linalg_eig_z(a, lambda, right, left, overwrite_a, err)

    矩阵 A 的特征分解，返回一个包含特征值的数组lambda，以及可选的右或左特征向量。

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(inout), target :: a(:,:)

    输入矩阵 A[m,n]
    complex(kind=dp), intent(out) :: lambda(:)

    特征值数组
    complex(kind=dp), intent(out), 可选的， target :: right(:,:)

    RIGHT 的列包含 A 的右特征向量
    complex(kind=dp), intent(out), 可选的， target :: left(:,:)

    LEFT 的列包含 A 的左特征向量
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] 可以覆盖和销毁 A 数据吗？
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • 私有模块子程序 stdlib_linalg_real_eig_d(a, lambda, right, left, overwrite_a, err)

    矩阵 A 的特征分解，返回一个包含实数特征值的数组lambda，以及可选的右或左特征向量。如果特征值具有非平凡的虚部，则返回错误。

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(inout), target :: a(:,:)

    输入矩阵 A[m,n]
    real(kind=dp), intent(out) :: lambda(:)

    实数特征值数组
    complex(kind=dp), intent(out), 可选的， target :: right(:,:)

    RIGHT 的列包含 A 的右特征向量
    complex(kind=dp), intent(out), 可选的， target :: left(:,:)

    LEFT 的列包含 A 的左特征向量
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] 可以覆盖和销毁 A 数据吗？
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • 私有模块子程序 stdlib_linalg_real_eig_s(a, lambda, right, left, overwrite_a, err)

    矩阵 A 的特征分解，返回一个包含实数特征值的数组lambda，以及可选的右或左特征向量。如果特征值具有非平凡的虚部，则返回错误。

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(inout), target :: a(:,:)

    输入矩阵 A[m,n]
    real(kind=sp), intent(out) :: lambda(:)

    实数特征值数组
    complex(kind=sp), intent(out), 可选的， target :: right(:,:)

    RIGHT 的列包含 A 的右特征向量
    complex(kind=sp), intent(out), 可选的， target :: left(:,:)

    LEFT 的列包含 A 的左特征向量
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] 可以覆盖和销毁 A 数据吗？
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

公共接口 eigh

求解特征分解对于实对称或复厄米方阵。( 规范）

摘要

计算实对称或复厄米方阵的特征值和特征向量的子程序接口。

描述

此接口提供计算实对称或复厄米方阵的特征值以及可选的特征向量的方法。支持的数据类型包括real和complex。矩阵必须是对称的（如果为real）或厄米特的（如果为complex）。仅访问矩阵的下半部分或上半部分，用户可以使用可选的upper_a标志选择（默认：使用下半部分）。向量是正交的，并且可以作为可选矩阵vectors的列返回，该矩阵与A具有相同的类型和大小。特征值lambda和特征向量矩阵都需要用户预先分配空间。

注意

该解决方案基于 LAPACK 的特征问题求解器*SYEV/*HEEV。

注意

BLAS/LAPACK 后端目前不支持扩展精度 (xdp)。

  • 私有模块子程序 stdlib_linalg_eigh_c(a, lambda, vectors, upper_a, overwrite_a, err)

    实对称或复厄米矩阵 A 的特征分解，返回一个包含特征值的数组lambda，以及可选的右或左特征向量。

    参数

    类型 意图可选 属性 名称
    complex(kind=sp),

    		 intent(inout), target :: a(:,:)

    输入矩阵 A[m,n]
    real(kind=sp), intent(out) :: lambda(:)

    特征值数组
    complex(kind=sp), intent(out), 可选的， target :: vectors(:,:)

    矩阵 A 的正交特征向量存储在 vectors 的列中
    logical(kind=lk), intent(in), optional :: upper_a

    [可选] 是否使用 A 的上/下三角部分？默认值：下三角
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] 可以覆盖和销毁 A 数据吗？
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • private module subroutine stdlib_linalg_eigh_d(a, lambda, vectors, upper_a, overwrite_a, err)

    实对称或复厄米矩阵 A 的特征分解，返回一个包含特征值的数组lambda，以及可选的右或左特征向量。

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(inout), target :: a(:,:)

    输入矩阵 A[m,n]
    real(kind=dp), intent(out) :: lambda(:)

    特征值数组
    real(kind=dp), intent(out), 可选的， target :: vectors(:,:)

    矩阵 A 的正交特征向量存储在 vectors 的列中
    logical(kind=lk), intent(in), optional :: upper_a

    [可选] 是否使用 A 的上/下三角部分？默认值：下三角
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] 可以覆盖和销毁 A 数据吗？
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • private module subroutine stdlib_linalg_eigh_s(a, lambda, vectors, upper_a, overwrite_a, err)

    实对称或复厄米矩阵 A 的特征分解，返回一个包含特征值的数组lambda，以及可选的右或左特征向量。

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(inout), target :: a(:,:)

    输入矩阵 A[m,n]
    real(kind=sp), intent(out) :: lambda(:)

    特征值数组
    real(kind=sp), intent(out), 可选的， target :: vectors(:,:)

    矩阵 A 的正交特征向量存储在 vectors 的列中
    logical(kind=lk), intent(in), optional :: upper_a

    [可选] 是否使用 A 的上/下三角部分？默认值：下三角
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] 可以覆盖和销毁 A 数据吗？
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • private module subroutine stdlib_linalg_eigh_z(a, lambda, vectors, upper_a, overwrite_a, err)

    实对称或复厄米矩阵 A 的特征分解，返回一个包含特征值的数组lambda，以及可选的右或左特征向量。

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(inout), target :: a(:,:)

    输入矩阵 A[m,n]
    real(kind=dp), intent(out) :: lambda(:)

    特征值数组
    complex(kind=dp), intent(out), 可选的， target :: vectors(:,:)

    矩阵 A 的正交特征向量存储在 vectors 的列中
    logical(kind=lk), intent(in), optional :: upper_a

    [可选] 是否使用 A 的上/下三角部分？默认值：下三角
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] 可以覆盖和销毁 A 数据吗？
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

public interface eigvals

返回特征值, ，对于方阵。(规范)

摘要

计算方阵特征值的函数接口。

描述

此接口提供用于返回一般方阵特征值的函数。支持的数据类型包括real和complex，并且不对矩阵结构做任何假设。如果失败，则会抛出error stop；否则，错误信息可以作为可选的type(linalg_state_type)输出标志返回。

注意

该解决方案基于 LAPACK 的通用特征问题求解器*GEEV。

注意

BLAS/LAPACK 后端目前不支持扩展精度 (xdp)。

  • private module function stdlib_linalg_eigvals_c(a, err) result(lambda)

    返回矩阵 A 的特征值数组。

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(in), target :: a(:,:)

    输入矩阵 A[m,n]
    type(linalg_state_type), intent(out) :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

    返回值 complex(kind=sp), allocatable, (:)

    奇异值数组

  • private module function stdlib_linalg_eigvals_d(a, err) result(lambda)

    返回矩阵 A 的特征值数组。

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(in), target :: a(:,:)

    输入矩阵 A[m,n]
    type(linalg_state_type), intent(out) :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

    返回值 complex(kind=dp), allocatable, (:)

    奇异值数组

  • private module function stdlib_linalg_eigvals_noerr_c(a) result(lambda)

    返回矩阵 A 的特征值数组。

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(in), target :: a(:,:)

    输入矩阵 A[m,n]

    返回值 complex(kind=sp), allocatable, (:)

    奇异值数组

  • private module function stdlib_linalg_eigvals_noerr_d(a) result(lambda)

    返回矩阵 A 的特征值数组。

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(in), target :: a(:,:)

    输入矩阵 A[m,n]

    返回值 complex(kind=dp), allocatable, (:)

    奇异值数组

  • private module function stdlib_linalg_eigvals_noerr_s(a) result(lambda)

    返回矩阵 A 的特征值数组。

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(in), target :: a(:,:)

    输入矩阵 A[m,n]

    返回值 complex(kind=sp), allocatable, (:)

    奇异值数组

  • private module function stdlib_linalg_eigvals_noerr_z(a) result(lambda)

    返回矩阵 A 的特征值数组。

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(in), target :: a(:,:)

    输入矩阵 A[m,n]

    返回值 complex(kind=dp), allocatable, (:)

    奇异值数组

  • private module function stdlib_linalg_eigvals_s(a, err) result(lambda)

    返回矩阵 A 的特征值数组。

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(in), target :: a(:,:)

    输入矩阵 A[m,n]
    type(linalg_state_type), intent(out) :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

    返回值 complex(kind=sp), allocatable, (:)

    奇异值数组

  • private module function stdlib_linalg_eigvals_z(a, err) result(lambda)

    返回矩阵 A 的特征值数组。

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(in), target :: a(:,:)

    输入矩阵 A[m,n]
    type(linalg_state_type), intent(out) :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

    返回值 complex(kind=dp), allocatable, (:)

    奇异值数组

public interface eigvalsh

返回特征值, ，对于实对称或复厄米方阵。(规范)

摘要

计算实对称或复厄米特方阵特征值的函数接口。

描述

此接口提供用于返回实对称或复厄米特方阵特征值的函数。支持的数据类型包括real和complex。矩阵必须是对称的（如果为real）或厄米特的（如果为complex）。仅访问矩阵的下三角或上三角部分，用户可以使用可选的upper_a标志（默认值：使用下三角部分）进行选择。如果失败，则会抛出error stop；否则，错误信息可以作为可选的type(linalg_state_type)输出标志返回。

注意

该解决方案基于 LAPACK 的特征问题求解器*SYEV/*HEEV。

注意

BLAS/LAPACK 后端目前不支持扩展精度 (xdp)。

  • private module function stdlib_linalg_eigvalsh_c(a, upper_a, err) result(lambda)

    返回实对称/复厄米特矩阵 A 的特征值数组

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(in), target :: a(:,:)

    输入矩阵 A[m,n]
    logical(kind=lk), intent(in), optional :: upper_a

    [可选] 是否使用 A 的上/下三角部分？默认值：下三角
    type(linalg_state_type), intent(out) :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

    返回值 real(kind=sp), allocatable, (:)

    奇异值数组

  • private module function stdlib_linalg_eigvalsh_d(a, upper_a, err) result(lambda)

    返回实对称/复厄米特矩阵 A 的特征值数组

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(in), target :: a(:,:)

    输入矩阵 A[m,n]
    logical(kind=lk), intent(in), optional :: upper_a

    [可选] 是否使用 A 的上/下三角部分？默认值：下三角
    type(linalg_state_type), intent(out) :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

    返回值 real(kind=dp), allocatable, (:)

    奇异值数组

  • private module function stdlib_linalg_eigvalsh_noerr_c(a, upper_a) result(lambda)

    返回实对称/复厄米特矩阵 A 的特征值数组

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(in), target :: a(:,:)

    输入矩阵 A[m,n]
    logical(kind=lk), intent(in), optional :: upper_a

    [可选] 是否使用 A 的上/下三角部分？默认值：下三角

    返回值 real(kind=sp), allocatable, (:)

    奇异值数组

  • private module function stdlib_linalg_eigvalsh_noerr_d(a, upper_a) result(lambda)

    返回实对称/复厄米特矩阵 A 的特征值数组

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(in), target :: a(:,:)

    输入矩阵 A[m,n]
    logical(kind=lk), intent(in), optional :: upper_a

    [可选] 是否使用 A 的上/下三角部分？默认值：下三角

    返回值 real(kind=dp), allocatable, (:)

    奇异值数组

  • private module function stdlib_linalg_eigvalsh_noerr_s(a, upper_a) result(lambda)

    返回实对称/复厄米特矩阵 A 的特征值数组

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(in), target :: a(:,:)

    输入矩阵 A[m,n]
    logical(kind=lk), intent(in), optional :: upper_a

    [可选] 是否使用 A 的上/下三角部分？默认值：下三角

    返回值 real(kind=sp), allocatable, (:)

    奇异值数组

  • private module function stdlib_linalg_eigvalsh_noerr_z(a, upper_a) result(lambda)

    返回实对称/复厄米特矩阵 A 的特征值数组

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(in), target :: a(:,:)

    输入矩阵 A[m,n]
    logical(kind=lk), intent(in), optional :: upper_a

    [可选] 是否使用 A 的上/下三角部分？默认值：下三角

    返回值 real(kind=dp), allocatable, (:)

    奇异值数组

  • private module function stdlib_linalg_eigvalsh_s(a, upper_a, err) result(lambda)

    返回实对称/复厄米特矩阵 A 的特征值数组

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(in), target :: a(:,:)

    输入矩阵 A[m,n]
    logical(kind=lk), intent(in), optional :: upper_a

    [可选] 是否使用 A 的上/下三角部分？默认值：下三角
    type(linalg_state_type), intent(out) :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

    返回值 real(kind=sp), allocatable, (:)

    奇异值数组

  • private module function stdlib_linalg_eigvalsh_z(a, upper_a, err) result(lambda)

    返回实对称/复厄米特矩阵 A 的特征值数组

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(in), target :: a(:,:)

    输入矩阵 A[m,n]
    logical(kind=lk), intent(in), optional :: upper_a

    [可选] 是否使用 A 的上/下三角部分？默认值：下三角
    type(linalg_state_type), intent(out) :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

    返回值 real(kind=dp), allocatable, (:)

    奇异值数组

public interface inv

方阵的逆矩阵 (规范)

摘要

此接口提供用于计算方阵real或complex的逆矩阵的方法。逆矩阵定义为.

描述

此函数接口提供返回方阵逆矩阵的方法。
支持的数据类型包括real和complex。逆矩阵作为函数结果返回。如果矩阵奇异或大小无效，则会引发异常，如果未提供状态标志err，则会触发error stop。

注意

提供的函数适用于方阵。

  • private module function stdlib_linalg_inverse_c(a, err) result(inva)

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(in) :: a(:,:)

    输入矩阵 a[n,n]
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

    返回值 complex(kind=sp), allocatable, (:,:)

    输出矩阵逆矩阵

  • private module function stdlib_linalg_inverse_d(a, err) result(inva)

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(in) :: a(:,:)

    输入矩阵 a[n,n]
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

    返回值 real(kind=dp), allocatable, (:,:)

    输出矩阵逆矩阵

  • private module function stdlib_linalg_inverse_s(a, err) result(inva)

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(in) :: a(:,:)

    输入矩阵 a[n,n]
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

    返回值 real(kind=sp), allocatable, (:,:)

    输出矩阵逆矩阵

  • private module function stdlib_linalg_inverse_z(a, err) result(inva)

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(in) :: a(:,:)

    输入矩阵 a[n,n]
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

    返回值 complex(kind=dp), allocatable, (:,:)

    输出矩阵逆矩阵

public interface invert

方阵的求逆 (规范)

摘要

此接口提供用于就地求real或complex方阵逆矩阵的方法。逆矩阵定义为.

描述

此子程序接口提供了一种计算矩阵逆矩阵的方法。
支持的数据类型包括real和complex。用户可以提供唯一的矩阵参数a。在这种情况下，a将被输出时的逆矩阵替换。否则，用户可以提供两个单独的参数：输入矩阵a和输出矩阵inva。在这种情况下，a不会被修改，逆矩阵将返回到inva中。可以为枢轴索引数组pivot提供预分配的存储空间。如果提供了所有预分配的工作空间，则使用此接口时不会发生内部内存分配。

注意

提供的子程序适用于方阵。

  • private module subroutine stdlib_linalg_invert_inplace_c(a, pivot, err)

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(inout) :: a(:,:)

    输入矩阵 a[n,n]
    integer(kind=ilp), intent(inout), 可选的， target :: pivot(:)

    [可选] 对角枢轴索引的存储数组
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • private module subroutine stdlib_linalg_invert_inplace_d(a, pivot, err)

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(inout) :: a(:,:)

    输入矩阵 a[n,n]
    integer(kind=ilp), intent(inout), 可选的， target :: pivot(:)

    [可选] 对角枢轴索引的存储数组
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • private module subroutine stdlib_linalg_invert_inplace_s(a, pivot, err)

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(inout) :: a(:,:)

    输入矩阵 a[n,n]
    integer(kind=ilp), intent(inout), 可选的， target :: pivot(:)

    [可选] 对角枢轴索引的存储数组
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • private module subroutine stdlib_linalg_invert_inplace_z(a, pivot, err)

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(inout) :: a(:,:)

    输入矩阵 a[n,n]
    integer(kind=ilp), intent(inout), 可选的， target :: pivot(:)

    [可选] 对角枢轴索引的存储数组
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • private module subroutine stdlib_linalg_invert_split_c(a, inva, pivot, err)

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(in) :: a(:,:)

    输入矩阵 a[n,n]。
    complex(kind=sp), intent(out) :: inva(:,:)

    逆矩阵 a[n,n]。
    integer(kind=ilp), intent(inout), 可选的， target :: pivot(:)

    [可选] 对角枢轴索引的存储数组
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • private module subroutine stdlib_linalg_invert_split_d(a, inva, pivot, err)

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(in) :: a(:,:)

    输入矩阵 a[n,n]。
    real(kind=dp), intent(out) :: inva(:,:)

    逆矩阵 a[n,n]。
    integer(kind=ilp), intent(inout), 可选的， target :: pivot(:)

    [可选] 对角枢轴索引的存储数组
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • private module subroutine stdlib_linalg_invert_split_s(a, inva, pivot, err)

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(in) :: a(:,:)

    输入矩阵 a[n,n]。
    real(kind=sp), intent(out) :: inva(:,:)

    逆矩阵 a[n,n]。
    integer(kind=ilp), intent(inout), 可选的， target :: pivot(:)

    [可选] 对角枢轴索引的存储数组
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • private module subroutine stdlib_linalg_invert_split_z(a, inva, pivot, err)

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(in) :: a(:,:)

    输入矩阵 a[n,n]。
    complex(kind=dp), intent(out) :: inva(:,:)

    逆矩阵 a[n,n]。
    integer(kind=ilp), intent(inout), 可选的， target :: pivot(:)

    [可选] 对角枢轴索引的存储数组
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

public interface is_diagonal

检查矩阵（秩为 2 的数组）是否为对角矩阵（规范）

  • 私有纯函数 is_diagonal_rsp(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_diagonal_rdp(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_diagonal_csp(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_diagonal_cdp(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_diagonal_iint8(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int8), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_diagonal_iint16(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int16), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_diagonal_iint32(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int32), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_diagonal_iint64(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int64), intent(in) :: A(:,:)

    返回值 逻辑型

公共接口 is_hermitian

检查矩阵（秩为 2 的数组）是否为厄米特矩阵（规范）

  • 私有纯函数 is_hermitian_rsp(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_hermitian_rdp(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_hermitian_csp(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_hermitian_cdp(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_hermitian_iint8(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int8), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_hermitian_iint16(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int16), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_hermitian_iint32(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int32), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_hermitian_iint64(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int64), intent(in) :: A(:,:)

    返回值 逻辑型

公共接口 is_hessenberg

检查矩阵（秩为 2 的数组）是否为 Hessenberg 矩阵（规范）

  • 私有函数 is_hessenberg_rsp(A, uplo) 结果(res)

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(in) :: A(:,:)
    character(len=1), intent(in) :: uplo

    返回值 逻辑型

  • 私有函数 is_hessenberg_rdp(A, uplo) 结果(res)

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(in) :: A(:,:)
    character(len=1), intent(in) :: uplo

    返回值 逻辑型

  • 私有函数 is_hessenberg_csp(A, uplo) 结果(res)

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(in) :: A(:,:)
    character(len=1), intent(in) :: uplo

    返回值 逻辑型

  • 私有函数 is_hessenberg_cdp(A, uplo) 结果(res)

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(in) :: A(:,:)
    character(len=1), intent(in) :: uplo

    返回值 逻辑型

  • 私有函数 is_hessenberg_iint8(A, uplo) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int8), intent(in) :: A(:,:)
    character(len=1), intent(in) :: uplo

    返回值 逻辑型

  • 私有函数 is_hessenberg_iint16(A, uplo) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int16), intent(in) :: A(:,:)
    character(len=1), intent(in) :: uplo

    返回值 逻辑型

  • 私有函数 is_hessenberg_iint32(A, uplo) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int32), intent(in) :: A(:,:)
    character(len=1), intent(in) :: uplo

    返回值 逻辑型

  • 私有函数 is_hessenberg_iint64(A, uplo) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int64), intent(in) :: A(:,:)
    character(len=1), intent(in) :: uplo

    返回值 逻辑型

公共接口 is_skew_symmetric

检查矩阵（秩为 2 的数组）是否为反对称矩阵（规范）

  • 私有纯函数 is_skew_symmetric_rsp(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_skew_symmetric_rdp(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_skew_symmetric_csp(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_skew_symmetric_cdp(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_skew_symmetric_iint8(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int8), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_skew_symmetric_iint16(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int16), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_skew_symmetric_iint32(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int32), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_skew_symmetric_iint64(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int64), intent(in) :: A(:,:)

    返回值 逻辑型

公共接口 is_square

检查矩阵（秩为 2 的数组）是否为方阵（规范）

  • 私有纯函数 is_square_rsp(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_square_rdp(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_square_csp(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_square_cdp(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_square_iint8(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int8), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_square_iint16(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int16), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_square_iint32(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int32), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_square_iint64(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int64), intent(in) :: A(:,:)

    返回值 逻辑型

公共接口 is_symmetric

检查矩阵（秩为 2 的数组）是否为对称矩阵（规范）

  • 私有纯函数 is_symmetric_rsp(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_symmetric_rdp(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_symmetric_csp(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_symmetric_cdp(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_symmetric_iint8(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int8), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_symmetric_iint16(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int16), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_symmetric_iint32(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int32), intent(in) :: A(:,:)

    返回值 逻辑型

  • 私有纯函数 is_symmetric_iint64(A) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int64), intent(in) :: A(:,:)

    返回值 逻辑型

公共接口 is_triangular

检查矩阵（秩为 2 的数组）是否为三角矩阵（规范）

  • 私有函数 is_triangular_rsp(A, uplo) 结果(res)

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(in) :: A(:,:)
    character(len=1), intent(in) :: uplo

    返回值 逻辑型

  • 私有函数 is_triangular_rdp(A, uplo) 结果(res)

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(in) :: A(:,:)
    character(len=1), intent(in) :: uplo

    返回值 逻辑型

  • 私有函数 is_triangular_csp(A, uplo) 结果(res)

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(in) :: A(:,:)
    character(len=1), intent(in) :: uplo

    返回值 逻辑型

  • 私有函数 is_triangular_cdp(A, uplo) 结果(res)

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(in) :: A(:,:)
    character(len=1), intent(in) :: uplo

    返回值 逻辑型

  • 私有函数 is_triangular_iint8(A, uplo) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int8), intent(in) :: A(:,:)
    character(len=1), intent(in) :: uplo

    返回值 逻辑型

  • 私有函数 is_triangular_iint16(A, uplo) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int16), intent(in) :: A(:,:)
    character(len=1), intent(in) :: uplo

    返回值 逻辑型

  • 私有函数 is_triangular_iint32(A, uplo) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int32), intent(in) :: A(:,:)
    character(len=1), intent(in) :: uplo

    返回值 逻辑型

  • 私有函数 is_triangular_iint64(A, uplo) 结果(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int64), intent(in) :: A(:,:)
    character(len=1), intent(in) :: uplo

    返回值 逻辑型

公共接口 kronecker_product

计算两个大小分别为 M1xN1 和 M2xN2 的数组的克罗内克积，返回一个 (M1M2)x(N1N2) 数组（规范）

  • 私有纯模块函数 kronecker_product_cdp(A, B) 结果(C)

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(in) :: A(:,:)
    complex(kind=dp), intent(in) :: B(:,:)

    返回值 complex(kind=dp), (size(A,dim=1)*size(B,dim=1),size(A,dim=2)*size(B,dim=2))

  • 私有纯模块函数 kronecker_product_csp(A, B) 结果(C)

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(in) :: A(:,:)
    complex(kind=sp), intent(in) :: B(:,:)

    返回值 complex(kind=sp), (size(A,dim=1)*size(B,dim=1),size(A,dim=2)*size(B,dim=2))

  • 私有纯模块函数 kronecker_product_iint16(A, B) 结果(C)

    参数

    类型 意图可选 属性 名称
    integer(kind=int16), intent(in) :: A(:,:)
    integer(kind=int16), intent(in) :: B(:,:)

    返回值 integer(kind=int16), (size(A,dim=1)*size(B,dim=1),size(A,dim=2)*size(B,dim=2))

  • 私有纯模块函数 kronecker_product_iint32(A, B) 结果(C)

    参数

    类型 意图可选 属性 名称
    integer(kind=int32), intent(in) :: A(:,:)
    integer(kind=int32), intent(in) :: B(:,:)

    返回值 integer(kind=int32), (size(A,dim=1)*size(B,dim=1),size(A,dim=2)*size(B,dim=2))

  • 私有纯模块函数 kronecker_product_iint64(A, B) 结果(C)

    参数

    类型 意图可选 属性 名称
    integer(kind=int64), intent(in) :: A(:,:)
    integer(kind=int64), intent(in) :: B(:,:)

    返回值 integer(kind=int64), (size(A,dim=1)*size(B,dim=1),size(A,dim=2)*size(B,dim=2))

  • 私有纯模块函数 kronecker_product_iint8(A, B) 结果(C)

    参数

    类型 意图可选 属性 名称
    integer(kind=int8), intent(in) :: A(:,:)
    integer(kind=int8), intent(in) :: B(:,:)

    返回值 integer(kind=int8), (size(A,dim=1)*size(B,dim=1),size(A,dim=2)*size(B,dim=2))

  • 私有纯模块函数 kronecker_product_rdp(A, B) 结果(C)

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(in) :: A(:,:)
    real(kind=dp), intent(in) :: B(:,:)

    返回值 real(kind=dp), (size(A,dim=1)*size(B,dim=1),size(A,dim=2)*size(B,dim=2))

  • 私有纯模块函数 kronecker_product_rsp(A, B) 结果(C)

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(in) :: A(:,:)
    real(kind=sp), intent(in) :: B(:,:)

    返回值 real(kind=sp), (size(A,dim=1)*size(B,dim=1),size(A,dim=2)*size(B,dim=2))

公共接口 lstsq

计算线性方程组的最小二乘解。（规范）

摘要

计算最小二乘解的接口，即 2 范数最小化解。

描述

此接口提供用于计算线性矩阵系统最小二乘解的方法。支持的数据类型包括 real 和 complex。

注意

该解基于 LAPACK 的奇异值分解 *GELSD 方法。

  • 私有模块函数 stdlib_linalg_c_lstsq_many(a, b, cond, overwrite_a, rank, err) 结果(x)

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(inout), target :: a(:,:)

    输入矩阵 a[n,n]
    complex(kind=sp), intent(in) :: b(:,:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    real(kind=sp), intent(in), optional :: cond

    [可选] 秩评估的截止值：奇异值 s(i)<=cond*maxval(s) 被认为是 0。
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] A、b 数据可以被覆盖和销毁吗？
    integer(kind=ilp), intent(out), optional :: rank

    [可选] 返回 A 的秩
    type(linalg_state_type),

    		 intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

    返回值 complex(kind=sp), 可分配，目标，(:,:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]

  • 私有模块函数 stdlib_linalg_c_lstsq_one(a, b, cond, overwrite_a, rank, err) result(x)

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(inout), target :: a(:,:)

    输入矩阵 a[n,n]
    complex(kind=sp), intent(in) :: b(:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    real(kind=sp), intent(in), optional :: cond

    [可选] 秩评估的截止值：奇异值 s(i)<=cond*maxval(s) 被认为是 0。
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] A、b 数据可以被覆盖和销毁吗？
    integer(kind=ilp), intent(out), optional :: rank

    [可选] 返回 A 的秩
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

    返回值 complex(kind=sp), 可分配，目标，(:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]

  • 私有模块函数 stdlib_linalg_d_lstsq_many(a, b, cond, overwrite_a, rank, err) result(x)

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(inout), target :: a(:,:)

    输入矩阵 a[n,n]
    real(kind=dp), intent(in) :: b(:,:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    real(kind=dp), intent(in), optional :: cond

    [可选] 秩评估的截止值：奇异值 s(i)<=cond*maxval(s) 被认为是 0。
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] A、b 数据可以被覆盖和销毁吗？
    integer(kind=ilp), intent(out), optional :: rank

    [可选] 返回 A 的秩
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

    返回值 real(kind=dp), 可分配，目标，(:,:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]

  • 私有模块函数 stdlib_linalg_d_lstsq_one(a, b, cond, overwrite_a, rank, err) result(x)

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(inout), target :: a(:,:)

    输入矩阵 a[n,n]
    real(kind=dp), intent(in) :: b(:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    real(kind=dp), intent(in), optional :: cond

    [可选] 秩评估的截止值：奇异值 s(i)<=cond*maxval(s) 被认为是 0。
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] A、b 数据可以被覆盖和销毁吗？
    integer(kind=ilp), intent(out), optional :: rank

    [可选] 返回 A 的秩
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

    返回值 real(kind=dp), 可分配，目标，(:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]

  • 私有模块函数 stdlib_linalg_s_lstsq_many(a, b, cond, overwrite_a, rank, err) result(x)

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(inout), target :: a(:,:)

    输入矩阵 a[n,n]
    real(kind=sp), intent(in) :: b(:,:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    real(kind=sp), intent(in), optional :: cond

    [可选] 秩评估的截止值：奇异值 s(i)<=cond*maxval(s) 被认为是 0。
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] A、b 数据可以被覆盖和销毁吗？
    integer(kind=ilp), intent(out), optional :: rank

    [可选] 返回 A 的秩
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

    返回值 real(kind=sp), 可分配，目标，(:,:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]

  • 私有模块函数 stdlib_linalg_s_lstsq_one(a, b, cond, overwrite_a, rank, err) result(x)

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(inout), target :: a(:,:)

    输入矩阵 a[n,n]
    real(kind=sp), intent(in) :: b(:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    real(kind=sp), intent(in), optional :: cond

    [可选] 秩评估的截止值：奇异值 s(i)<=cond*maxval(s) 被认为是 0。
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] A、b 数据可以被覆盖和销毁吗？
    integer(kind=ilp), intent(out), optional :: rank

    [可选] 返回 A 的秩
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

    返回值 real(kind=sp), 可分配，目标，(:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]

  • 私有模块函数 stdlib_linalg_z_lstsq_many(a, b, cond, overwrite_a, rank, err) result(x)

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(inout), target :: a(:,:)

    输入矩阵 a[n,n]
    complex(kind=dp), intent(in) :: b(:,:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    real(kind=dp), intent(in), optional :: cond

    [可选] 秩评估的截止值：奇异值 s(i)<=cond*maxval(s) 被认为是 0。
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] A、b 数据可以被覆盖和销毁吗？
    integer(kind=ilp), intent(out), optional :: rank

    [可选] 返回 A 的秩
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

    返回值 complex(kind=dp), 可分配，目标，(:,:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]

  • 私有模块函数 stdlib_linalg_z_lstsq_one(a, b, cond, overwrite_a, rank, err) result(x)

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(inout), target :: a(:,:)

    输入矩阵 a[n,n]
    complex(kind=dp), intent(in) :: b(:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    real(kind=dp), intent(in), optional :: cond

    [可选] 秩评估的截止值：奇异值 s(i)<=cond*maxval(s) 被认为是 0。
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] A、b 数据可以被覆盖和销毁吗？
    integer(kind=ilp), intent(out), optional :: rank

    [可选] 返回 A 的秩
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

    返回值 complex(kind=dp), 可分配，目标，(:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]

公共接口 lstsq_space

计算最小二乘解算器所需的整数、实数[, 复数]工作空间(规范)

描述

此接口提供最小二乘解算器所需的整数、实数[, 复数]工作空间的大小。如果需要对同一系统进行多次最小二乘求解，则可以使用这些大小来预分配工作数组。如果提供了预分配的工作数组，则不会发生内部分配。

  • 私有纯模块子程序 stdlib_linalg_c_lstsq_space_many(a, b, lrwork, liwork, lcwork)

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(in), target :: a(:,:)

    输入矩阵 a[m,n]
    complex(kind=sp), intent(in) :: b(:,:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    integer(kind=ilp), intent(out) :: lrwork

    工作空间数组的大小
    integer(kind=ilp), intent(out) :: liwork

    工作空间数组的大小
    integer(kind=ilp), intent(out) :: lcwork

    工作空间数组的大小

  • 私有纯模块子程序 stdlib_linalg_c_lstsq_space_one(a, b, lrwork, liwork, lcwork)

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(in), target :: a(:,:)

    输入矩阵 a[m,n]
    complex(kind=sp), intent(in) :: b(:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    integer(kind=ilp), intent(out) :: lrwork

    工作空间数组的大小
    integer(kind=ilp), intent(out) :: liwork

    工作空间数组的大小
    integer(kind=ilp), intent(out) :: lcwork

    工作空间数组的大小

  • 私有纯模块子程序 stdlib_linalg_d_lstsq_space_many(a, b, lrwork, liwork)

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(in), target :: a(:,:)

    输入矩阵 a[m,n]
    real(kind=dp), intent(in) :: b(:,:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    integer(kind=ilp), intent(out) :: lrwork

    工作空间数组的大小
    integer(kind=ilp), intent(out) :: liwork

    工作空间数组的大小

  • 私有纯模块子程序 stdlib_linalg_d_lstsq_space_one(a, b, lrwork, liwork)

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(in), target :: a(:,:)

    输入矩阵 a[m,n]
    real(kind=dp), intent(in) :: b(:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    integer(kind=ilp), intent(out) :: lrwork

    工作空间数组的大小
    integer(kind=ilp), intent(out) :: liwork

    工作空间数组的大小

  • 私有纯模块子程序 stdlib_linalg_s_lstsq_space_many(a, b, lrwork, liwork)

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(in), target :: a(:,:)

    输入矩阵 a[m,n]
    real(kind=sp), intent(in) :: b(:,:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    integer(kind=ilp), intent(out) :: lrwork

    工作空间数组的大小
    integer(kind=ilp), intent(out) :: liwork

    工作空间数组的大小

  • 私有纯模块子程序 stdlib_linalg_s_lstsq_space_one(a, b, lrwork, liwork)

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(in), target :: a(:,:)

    输入矩阵 a[m,n]
    real(kind=sp), intent(in) :: b(:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    integer(kind=ilp), intent(out) :: lrwork

    工作空间数组的大小
    integer(kind=ilp), intent(out) :: liwork

    工作空间数组的大小

  • 私有纯模块子程序 stdlib_linalg_z_lstsq_space_many(a, b, lrwork, liwork, lcwork)

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(in), target :: a(:,:)

    输入矩阵 a[m,n]
    complex(kind=dp), intent(in) :: b(:,:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    integer(kind=ilp), intent(out) :: lrwork

    工作空间数组的大小
    integer(kind=ilp), intent(out) :: liwork

    工作空间数组的大小
    integer(kind=ilp), intent(out) :: lcwork

    工作空间数组的大小

  • 私有纯模块子程序 stdlib_linalg_z_lstsq_space_one(a, b, lrwork, liwork, lcwork)

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(in), target :: a(:,:)

    输入矩阵 a[m,n]
    complex(kind=dp), intent(in) :: b(:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    integer(kind=ilp), intent(out) :: lrwork

    工作空间数组的大小
    integer(kind=ilp), intent(out) :: liwork

    工作空间数组的大小
    integer(kind=ilp), intent(out) :: lcwork

    工作空间数组的大小

公共接口 operator(.det.)

方阵的行列式运算符(规范)

摘要

用于计算矩阵行列式的纯运算符接口。

描述

此纯运算符接口提供了一种方便的方法来计算矩阵的行列式。支持的数据类型包括实数和复数。

注意

提供的函数适用于方阵。

注意

BLAS/LAPACK 后端目前不支持扩展精度 (xdp)。

示例

    ! ...
    real(sp) :: matrix(3,3), d
    matrix = reshape([1, 2, 3, 4, 5, 6, 7, 8, 9], [3, 3])
    d = .det.matrix
    ! ...

  • 私有接口 stdlib_linalg_pure_rspdeterminant()

    参数

    无

  • 私有接口 stdlib_linalg_pure_rdpdeterminant()

    参数

    无

  • 私有接口 stdlib_linalg_pure_cspdeterminant()

    参数

    无

  • 私有接口 stdlib_linalg_pure_cdpdeterminant()

    参数

    无

公共接口 operator(.inv.)

方阵的逆运算符(规范)

摘要

用于计算方阵real或complex逆的运算符接口。

描述

此运算符接口提供了一种方便的方法来计算矩阵的逆。支持的数据类型包括real和complex。在输入错误或奇异矩阵的情况下，将返回NaN。

注意

提供的函数适用于方阵。

  • 私有模块函数 stdlib_linalg_inverse_c_operator(a) result(inva)

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(in) :: a(:,:)

    输入矩阵 a[n,n]

    返回值 complex(kind=sp), allocatable, (:,:)

    结果矩阵

  • 私有模块函数 stdlib_linalg_inverse_d_operator(a) result(inva)

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(in) :: a(:,:)

    输入矩阵 a[n,n]

    返回值 real(kind=dp), allocatable, (:,:)

    结果矩阵

  • 私有模块函数 stdlib_linalg_inverse_s_operator(a) result(inva)

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(in) :: a(:,:)

    输入矩阵 a[n,n]

    返回值 real(kind=sp), allocatable, (:,:)

    结果矩阵

  • 私有模块函数 stdlib_linalg_inverse_z_operator(a) result(inva)

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(in) :: a(:,:)

    输入矩阵 a[n,n]

    返回值 complex(kind=dp), allocatable, (:,:)

    结果矩阵

公共接口 outer_product

计算两个向量的外积，返回一个秩为2的数组(规范)

  • 私有纯模块函数 outer_product_cdp(u, v) result(res)

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(in) :: u(:)
    complex(kind=dp), intent(in) :: v(:)

    返回值 complex(kind=dp), (size(u),size(v))

  • 私有纯模块函数 outer_product_csp(u, v) result(res)

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(in) :: u(:)
    complex(kind=sp), intent(in) :: v(:)

    返回值 complex(kind=sp), (size(u),size(v))

  • 私有纯模块函数 outer_product_iint16(u, v) result(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int16), intent(in) :: u(:)
    integer(kind=int16), intent(in) :: v(:)

    返回值 integer(kind=int16), (size(u),size(v))

  • 私有纯模块函数 outer_product_iint32(u, v) result(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int32), intent(in) :: u(:)
    integer(kind=int32), intent(in) :: v(:)

    返回值 integer(kind=int32), (size(u),size(v))

  • 私有纯模块函数 outer_product_iint64(u, v) result(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int64), intent(in) :: u(:)
    integer(kind=int64), intent(in) :: v(:)

    返回值 integer(kind=int64), (size(u),size(v))

  • 私有纯模块函数 outer_product_iint8(u, v) result(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int8), intent(in) :: u(:)
    integer(kind=int8), intent(in) :: v(:)

    返回值 integer(kind=int8), (size(u),size(v))

  • 私有纯模块函数 outer_product_rdp(u, v) result(res)

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(in) :: u(:)
    real(kind=dp), intent(in) :: v(:)

    返回值 real(kind=dp), (size(u),size(v))

  • 私有纯模块函数 outer_product_rsp(u, v) result(res)

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(in) :: u(:)
    real(kind=sp), intent(in) :: v(:)

    返回值 real(kind=sp), (size(u),size(v))

公共接口 solve

求解线性系统对于未知向量来自方阵。(规范)

摘要

用于求解由一般矩阵产生的线性系统的接口。

描述

此接口提供计算线性矩阵系统解的方法。支持的数据类型包括real和complex。不对矩阵结构做任何假设。该函数可以同时求解一个（来自 1 维右手边向量b(:)）或多个（来自 2 维右手边向量b(:,:)）系统。

注意

该解决方案基于 LAPACK 的通用 LU 分解基于求解器*GESV。

  • 私有纯模块函数 stdlib_linalg_c_pure_solve_many(a, b) result(x)

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(in) :: a(:,:)

    输入矩阵 a[n,n]
    complex(kind=sp), intent(in) :: b(:,:)

    右侧向量或数组，b[n] 或 b[n,nrhs]

    返回值 complex(kind=sp), 可分配，目标，(:,:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]

  • 私有纯模块函数 stdlib_linalg_c_pure_solve_one(a, b) result(x)

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(in) :: a(:,:)

    输入矩阵 a[n,n]
    complex(kind=sp), intent(in) :: b(:)

    右侧向量或数组，b[n] 或 b[n,nrhs]

    返回值 complex(kind=sp), 可分配，目标，(:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]

  • 私有模块函数 stdlib_linalg_c_solve_many(a, b, overwrite_a, err) result(x)

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(inout), target :: a(:,:)

    输入矩阵 a[n,n]
    complex(kind=sp), intent(in) :: b(:,:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] 可以覆盖和销毁 A 数据吗？
    type(linalg_state_type), intent(out) :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

    返回值 complex(kind=sp), 可分配，目标，(:,:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]

  • 私有模块函数 stdlib_linalg_c_solve_one(a, b, overwrite_a, err) result(x)

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(inout), target :: a(:,:)

    输入矩阵 a[n,n]
    complex(kind=sp), intent(in) :: b(:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] 可以覆盖和销毁 A 数据吗？
    type(linalg_state_type), intent(out) :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

    返回值 complex(kind=sp), 可分配，目标，(:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]

  • 私有纯模块函数 stdlib_linalg_d_pure_solve_many(a, b) result(x)

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(in) :: a(:,:)

    输入矩阵 a[n,n]
    real(kind=dp), intent(in) :: b(:,:)

    右侧向量或数组，b[n] 或 b[n,nrhs]

    返回值 real(kind=dp), 可分配，目标，(:,:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]

  • 私有纯模块函数 stdlib_linalg_d_pure_solve_one(a, b) result(x)

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(in) :: a(:,:)

    输入矩阵 a[n,n]
    real(kind=dp), intent(in) :: b(:)

    右侧向量或数组，b[n] 或 b[n,nrhs]

    返回值 real(kind=dp), 可分配，目标，(:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]

  • 私有模块函数 stdlib_linalg_d_solve_many(a, b, overwrite_a, err) result(x)

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(inout), target :: a(:,:)

    输入矩阵 a[n,n]
    real(kind=dp), intent(in) :: b(:,:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] 可以覆盖和销毁 A 数据吗？
    type(linalg_state_type), intent(out) :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

    返回值 real(kind=dp), 可分配，目标，(:,:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]

  • 私有模块函数 stdlib_linalg_d_solve_one(a, b, overwrite_a, err) result(x)

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(inout), target :: a(:,:)

    输入矩阵 a[n,n]
    real(kind=dp), intent(in) :: b(:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] 可以覆盖和销毁 A 数据吗？
    type(linalg_state_type), intent(out) :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

    返回值 real(kind=dp), 可分配，目标，(:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]

  • 私有纯模块函数 stdlib_linalg_s_pure_solve_many(a, b) result(x)

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(in) :: a(:,:)

    输入矩阵 a[n,n]
    real(kind=sp), intent(in) :: b(:,:)

    右侧向量或数组，b[n] 或 b[n,nrhs]

    返回值 real(kind=sp), 可分配，目标，(:,:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]

  • 私有纯模块函数 stdlib_linalg_s_pure_solve_one(a, b) result(x)

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(in) :: a(:,:)

    输入矩阵 a[n,n]
    real(kind=sp), intent(in) :: b(:)

    右侧向量或数组，b[n] 或 b[n,nrhs]

    返回值 real(kind=sp), 可分配，目标，(:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]

  • 私有模块函数 stdlib_linalg_s_solve_many(a, b, overwrite_a, err) result(x)

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(inout), target :: a(:,:)

    输入矩阵 a[n,n]
    real(kind=sp), intent(in) :: b(:,:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] 可以覆盖和销毁 A 数据吗？
    type(linalg_state_type), intent(out) :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

    返回值 real(kind=sp), 可分配，目标，(:,:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]

  • 私有模块函数 stdlib_linalg_s_solve_one(a, b, overwrite_a, err) result(x)

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(inout), target :: a(:,:)

    输入矩阵 a[n,n]
    real(kind=sp), intent(in) :: b(:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] 可以覆盖和销毁 A 数据吗？
    type(linalg_state_type), intent(out) :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

    返回值 real(kind=sp), 可分配，目标，(:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]

  • 私有纯模块函数 stdlib_linalg_z_pure_solve_many(a, b) result(x)

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(in) :: a(:,:)

    输入矩阵 a[n,n]
    complex(kind=dp), intent(in) :: b(:,:)

    右侧向量或数组，b[n] 或 b[n,nrhs]

    返回值 complex(kind=dp), 可分配，目标，(:,:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]

  • 私有纯模块函数 stdlib_linalg_z_pure_solve_one(a, b) result(x)

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(in) :: a(:,:)

    输入矩阵 a[n,n]
    complex(kind=dp), intent(in) :: b(:)

    右侧向量或数组，b[n] 或 b[n,nrhs]

    返回值 complex(kind=dp), 可分配，目标，(:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]

  • 私有模块函数 stdlib_linalg_z_solve_many(a, b, overwrite_a, err) result(x)

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(inout), target :: a(:,:)

    输入矩阵 a[n,n]
    complex(kind=dp), intent(in) :: b(:,:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] 可以覆盖和销毁 A 数据吗？
    type(linalg_state_type), intent(out) :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

    返回值 complex(kind=dp), 可分配，目标，(:,:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]

  • 私有模块函数 stdlib_linalg_z_solve_one(a, b, overwrite_a, err) result(x)

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(inout), target :: a(:,:)

    输入矩阵 a[n,n]
    complex(kind=dp), intent(in) :: b(:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] 可以覆盖和销毁 A 数据吗？
    type(linalg_state_type), intent(out) :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

    返回值 complex(kind=dp), 可分配，目标，(:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]

公共接口 solve_lstsq

计算线性方程组的最小二乘解. (规范)

摘要

计算最小二乘解的子程序接口，即2范数最小化解。

描述

此接口提供使用子程序计算线性矩阵系统最小二乘解的方法。支持的数据类型包括real和complex。如果提供了预分配的工作空间，则使用此接口时不会发生内部内存分配。

注意

该解基于 LAPACK 的奇异值分解 *GELSD 方法。

  • 私有模块子程序 stdlib_linalg_c_solve_lstsq_many(a, b, x, real_storage, int_storage, cmpl_storage, cond, singvals, overwrite_a, rank, err)

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(inout), target :: a(:,:)

    输入矩阵 a[n,n]
    complex(kind=sp), intent(in) :: b(:,:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    complex(kind=sp), intent(inout), 连续，目标 :: x(:,:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]
    real(kind=sp), intent(inout), 可选的， target :: real_storage(:)

    [可选] 实数工作存储空间
    integer(kind=ilp), intent(inout), 可选的， target :: int_storage(:)

    [可选] 整数工作存储空间
    complex(kind=sp), intent(inout), 可选的， target :: cmpl_storage(:)

    [可选] 复数工作存储空间
    real(kind=sp), intent(in), optional :: cond

    [可选] 秩评估的截止值：奇异值 s(i)<=cond*maxval(s) 被认为是 0。
    real(kind=sp), intent(out), 可选的， target :: singvals(:)

    [可选] 奇异值列表 [min(m,n)]，按降序排列，由SVD返回
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] A、b 数据可以被覆盖和销毁吗？
    integer(kind=ilp), intent(out), optional :: rank

    [可选] 返回 A 的秩
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • 私有模块子程序 stdlib_linalg_c_solve_lstsq_one(a, b, x, real_storage, int_storage, cmpl_storage, cond, singvals, overwrite_a, rank, err)

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(inout), target :: a(:,:)

    输入矩阵 a[n,n]
    complex(kind=sp), intent(in) :: b(:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    complex(kind=sp), intent(inout), 连续，目标 :: x(:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]
    real(kind=sp), intent(inout), 可选的， target :: real_storage(:)

    [可选] 实数工作存储空间
    integer(kind=ilp), intent(inout), 可选的， target :: int_storage(:)

    [可选] 整数工作存储空间
    complex(kind=sp), intent(inout), 可选的， target :: cmpl_storage(:)

    [可选] 复数工作存储空间
    real(kind=sp), intent(in), optional :: cond

    [可选] 秩评估的截止值：奇异值 s(i)<=cond*maxval(s) 被认为是 0。
    real(kind=sp), intent(out), 可选的， target :: singvals(:)

    [可选] 奇异值列表 [min(m,n)]，按降序排列，由SVD返回
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] A、b 数据可以被覆盖和销毁吗？
    integer(kind=ilp), intent(out), optional :: rank

    [可选] 返回 A 的秩
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • 私有模块子程序 stdlib_linalg_d_solve_lstsq_many(a, b, x, real_storage, int_storage, cond, singvals, overwrite_a, rank, err)

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(inout), target :: a(:,:)

    输入矩阵 a[n,n]
    real(kind=dp), intent(in) :: b(:,:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    real(kind=dp), intent(inout), 连续，目标 :: x(:,:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]
    real(kind=dp), intent(inout), 可选的， target :: real_storage(:)

    [可选] 实数工作存储空间
    integer(kind=ilp), intent(inout), 可选的， target :: int_storage(:)

    [可选] 整数工作存储空间
    real(kind=dp), intent(in), optional :: cond

    [可选] 秩评估的截止值：奇异值 s(i)<=cond*maxval(s) 被认为是 0。
    real(kind=dp), intent(out), 可选的， target :: singvals(:)

    [可选] 奇异值列表 [min(m,n)]，按降序排列，由SVD返回
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] A、b 数据可以被覆盖和销毁吗？
    integer(kind=ilp), intent(out), optional :: rank

    [可选] 返回 A 的秩
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • 私有模块子程序 stdlib_linalg_d_solve_lstsq_one(a, b, x, real_storage, int_storage, cond, singvals, overwrite_a, rank, err)

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(inout), target :: a(:,:)

    输入矩阵 a[n,n]
    real(kind=dp), intent(in) :: b(:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    real(kind=dp), intent(inout), 连续，目标 :: x(:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]
    real(kind=dp), intent(inout), 可选的， target :: real_storage(:)

    [可选] 实数工作存储空间
    integer(kind=ilp), intent(inout), 可选的， target :: int_storage(:)

    [可选] 整数工作存储空间
    real(kind=dp), intent(in), optional :: cond

    [可选] 秩评估的截止值：奇异值 s(i)<=cond*maxval(s) 被认为是 0。
    real(kind=dp), intent(out), 可选的， target :: singvals(:)

    [可选] 奇异值列表 [min(m,n)]，按降序排列，由SVD返回
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] A、b 数据可以被覆盖和销毁吗？
    integer(kind=ilp), intent(out), optional :: rank

    [可选] 返回 A 的秩
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • 私有模块子程序 stdlib_linalg_s_solve_lstsq_many(a, b, x, real_storage, int_storage, cond, singvals, overwrite_a, rank, err)

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(inout), target :: a(:,:)

    输入矩阵 a[n,n]
    real(kind=sp), intent(in) :: b(:,:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    real(kind=sp), intent(inout), 连续，目标 :: x(:,:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]
    real(kind=sp), intent(inout), 可选的， target :: real_storage(:)

    [可选] 实数工作存储空间
    integer(kind=ilp), intent(inout), 可选的， target :: int_storage(:)

    [可选] 整数工作存储空间
    real(kind=sp), intent(in), optional :: cond

    [可选] 秩评估的截止值：奇异值 s(i)<=cond*maxval(s) 被认为是 0。
    real(kind=sp), intent(out), 可选的， target :: singvals(:)

    [可选] 奇异值列表 [min(m,n)]，按降序排列，由SVD返回
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] A、b 数据可以被覆盖和销毁吗？
    integer(kind=ilp), intent(out), optional :: rank

    [可选] 返回 A 的秩
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • 私有模块子程序 stdlib_linalg_s_solve_lstsq_one(a, b, x, real_storage, int_storage, cond, singvals, overwrite_a, rank, err)

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(inout), target :: a(:,:)

    输入矩阵 a[n,n]
    real(kind=sp), intent(in) :: b(:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    real(kind=sp), intent(inout), 连续，目标 :: x(:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]
    real(kind=sp), intent(inout), 可选的， target :: real_storage(:)

    [可选] 实数工作存储空间
    integer(kind=ilp), intent(inout), 可选的， target :: int_storage(:)

    [可选] 整数工作存储空间
    real(kind=sp), intent(in), optional :: cond

    [可选] 秩评估的截止值：奇异值 s(i)<=cond*maxval(s) 被认为是 0。
    real(kind=sp), intent(out), 可选的， target :: singvals(:)

    [可选] 奇异值列表 [min(m,n)]，按降序排列，由SVD返回
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] A、b 数据可以被覆盖和销毁吗？
    integer(kind=ilp), intent(out), optional :: rank

    [可选] 返回 A 的秩
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • 私有模块子程序 stdlib_linalg_z_solve_lstsq_many(a, b, x, real_storage, int_storage, cmpl_storage, cond, singvals, overwrite_a, rank, err)

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(inout), target :: a(:,:)

    输入矩阵 a[n,n]
    complex(kind=dp), intent(in) :: b(:,:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    complex(kind=dp), intent(inout), 连续，目标 :: x(:,:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]
    real(kind=dp), intent(inout), 可选的， target :: real_storage(:)

    [可选] 实数工作存储空间
    integer(kind=ilp), intent(inout), 可选的， target :: int_storage(:)

    [可选] 整数工作存储空间
    complex(kind=dp), intent(inout), 可选的， target :: cmpl_storage(:)

    [可选] 复数工作存储空间
    real(kind=dp), intent(in), optional :: cond

    [可选] 秩评估的截止值：奇异值 s(i)<=cond*maxval(s) 被认为是 0。
    real(kind=dp), intent(out), 可选的， target :: singvals(:)

    [可选] 奇异值列表 [min(m,n)]，按降序排列，由SVD返回
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] A、b 数据可以被覆盖和销毁吗？
    integer(kind=ilp), intent(out), optional :: rank

    [可选] 返回 A 的秩
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • 私有模块子程序 stdlib_linalg_z_solve_lstsq_one(a, b, x, real_storage, int_storage, cmpl_storage, cond, singvals, overwrite_a, rank, err)

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(inout), target :: a(:,:)

    输入矩阵 a[n,n]
    complex(kind=dp), intent(in) :: b(:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    complex(kind=dp), intent(inout), 连续，目标 :: x(:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]
    real(kind=dp), intent(inout), 可选的， target :: real_storage(:)

    [可选] 实数工作存储空间
    integer(kind=ilp), intent(inout), 可选的， target :: int_storage(:)

    [可选] 整数工作存储空间
    complex(kind=dp), intent(inout), 可选的， target :: cmpl_storage(:)

    [可选] 复数工作存储空间
    real(kind=dp), intent(in), optional :: cond

    [可选] 秩评估的截止值：奇异值 s(i)<=cond*maxval(s) 被认为是 0。
    real(kind=dp), intent(out), 可选的， target :: singvals(:)

    [可选] 奇异值列表 [min(m,n)]，按降序排列，由SVD返回
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] A、b 数据可以被覆盖和销毁吗？
    integer(kind=ilp), intent(out), optional :: rank

    [可选] 返回 A 的秩
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

公共接口 solve_lu

求解线性系统对于未知向量来自方阵. (规范)

摘要

使用LU分解求解线性系统的子程序接口。

描述

此接口提供使用子程序计算线性矩阵系统解的方法。支持的数据类型包括real和complex。对矩阵结构不作任何假设。解向量x的预分配空间由用户提供，并且可以为枢轴索引数组pivot提供预分配空间。如果提供了所有预分配的工作空间，则使用此接口时不会发生内部内存分配。
该函数可以同时求解一个（来自1维右侧向量b(:)）或多个（来自2维右侧向量b(:,:)）系统。

注意

该解决方案基于 LAPACK 的通用 LU 分解基于求解器*GESV。

  • 私有纯模块子程序 stdlib_linalg_c_solve_lu_many(a, b, x, pivot, overwrite_a, err)

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(inout), target :: a(:,:)

    输入矩阵 a[n,n]
    complex(kind=sp), intent(in) :: b(:,:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    complex(kind=sp), intent(inout), 连续，目标 :: x(:,:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]
    integer(kind=ilp), intent(inout), 可选的， target :: pivot(:)

    [可选] 对角枢轴索引的存储数组
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] 可以覆盖和销毁 A 数据吗？
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • 私有纯模块子程序 stdlib_linalg_c_solve_lu_one(a, b, x, pivot, overwrite_a, err)

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(inout), target :: a(:,:)

    输入矩阵 a[n,n]
    complex(kind=sp), intent(in) :: b(:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    complex(kind=sp), intent(inout), 连续，目标 :: x(:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]
    integer(kind=ilp), intent(inout), 可选的， target :: pivot(:)

    [可选] 对角枢轴索引的存储数组
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] 可以覆盖和销毁 A 数据吗？
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • 私有纯模块子程序 stdlib_linalg_d_solve_lu_many(a, b, x, pivot, overwrite_a, err)

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(inout), target :: a(:,:)

    输入矩阵 a[n,n]
    real(kind=dp), intent(in) :: b(:,:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    real(kind=dp), intent(inout), 连续，目标 :: x(:,:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]
    integer(kind=ilp), intent(inout), 可选的， target :: pivot(:)

    [可选] 对角枢轴索引的存储数组
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] 可以覆盖和销毁 A 数据吗？
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • 私有纯模块子程序 stdlib_linalg_d_solve_lu_one(a, b, x, pivot, overwrite_a, err)

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(inout), target :: a(:,:)

    输入矩阵 a[n,n]
    real(kind=dp), intent(in) :: b(:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    real(kind=dp), intent(inout), 连续，目标 :: x(:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]
    integer(kind=ilp), intent(inout), 可选的， target :: pivot(:)

    [可选] 对角枢轴索引的存储数组
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] 可以覆盖和销毁 A 数据吗？
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • 私有纯模块子程序 stdlib_linalg_s_solve_lu_many(a, b, x, pivot, overwrite_a, err)

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(inout), target :: a(:,:)

    输入矩阵 a[n,n]
    real(kind=sp), intent(in) :: b(:,:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    real(kind=sp), intent(inout), 连续，目标 :: x(:,:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]
    integer(kind=ilp), intent(inout), 可选的， target :: pivot(:)

    [可选] 对角枢轴索引的存储数组
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] 可以覆盖和销毁 A 数据吗？
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • 私有纯模块子程序 stdlib_linalg_s_solve_lu_one(a, b, x, pivot, overwrite_a, err)

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(inout), target :: a(:,:)

    输入矩阵 a[n,n]
    real(kind=sp), intent(in) :: b(:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    real(kind=sp), intent(inout), 连续，目标 :: x(:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]
    integer(kind=ilp), intent(inout), 可选的， target :: pivot(:)

    [可选] 对角枢轴索引的存储数组
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] 可以覆盖和销毁 A 数据吗？
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • 私有纯模块子程序 stdlib_linalg_z_solve_lu_many(a, b, x, pivot, overwrite_a, err)

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(inout), target :: a(:,:)

    输入矩阵 a[n,n]
    complex(kind=dp), intent(in) :: b(:,:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    complex(kind=dp), intent(inout), 连续，目标 :: x(:,:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]
    integer(kind=ilp), intent(inout), 可选的， target :: pivot(:)

    [可选] 对角枢轴索引的存储数组
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] 可以覆盖和销毁 A 数据吗？
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • 私有纯模块子程序 stdlib_linalg_z_solve_lu_one(a, b, x, pivot, overwrite_a, err)

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(inout), target :: a(:,:)

    输入矩阵 a[n,n]
    complex(kind=dp), intent(in) :: b(:)

    右侧向量或数组，b[n] 或 b[n,nrhs]
    complex(kind=dp), intent(inout), 连续，目标 :: x(:)

    结果数组/矩阵 x[n] 或 x[n,nrhs]
    integer(kind=ilp), intent(inout), 可选的， target :: pivot(:)

    [可选] 对角枢轴索引的存储数组
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] 可以覆盖和销毁 A 数据吗？
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

公共接口 svd

计算real或complex二维矩阵的奇异值分解。（规范）

摘要

计算real或complex二维矩阵的奇异值分解的接口。

描述

此接口提供计算矩阵奇异值分解的方法。支持的数据类型包括real和complex。子程序返回一个real类型的奇异值数组，以及可选的左右奇异向量矩阵U和V。对于大小为[m,n]的矩阵A，U和V的完整矩阵存储应为[m,m]和[n,n]。可以选择使用部分存储[m,k]和[k,n]，k=min(m,n)，选择full_matrices=.false.。

注意

该解决方案基于LAPACK的奇异值分解*GESDD方法。

示例

    real(sp) :: a(2,3), s(2), u(2,2), vt(3,3) 
    a = reshape([3,2, 2,3, 2,-2],[2,3])

    call svd(A,s,u,v)
    print *, 'singular values = ',s

  • 私有模块子程序 stdlib_linalg_svd_c(a, s, u, vt, overwrite_a, full_matrices, err)

    摘要

    计算矩阵的奇异值分解

    描述

    此函数计算real或complex矩阵的奇异值分解，并返回奇异值数组，以及可选的左侧矩阵包含左侧酉奇异向量，以及右侧矩阵，包含右侧酉奇异向量。

    参数：a 输入大小为[m,n]的矩阵。参数：s 输出大小为[min(m,n)]的real数组，返回奇异值列表。参数：u [可选] 输出大小为[m,m]或[m,min(m,n)]（.not.full_matrices）的左侧奇异矩阵。包含奇异向量作为列。参数：vt [可选] 输出大小为[n,n]或[min(m,n),n]（.not.full_matrices）的右侧奇异矩阵。包含奇异向量作为行。
    参数：overwrite_a [可选] 指示是否可以覆盖输入矩阵的标志。参数：full_matrices [可选] 如果为.true.（默认），则矩阵和的大小为[m,m]，[n,n]。否则，它们为[m,k]，[k,n]，其中k=min(m,n)。参数：err [可选] 状态返回标志。

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(inout), target :: a(:,:)

    输入矩阵 A[m,n]
    real(kind=sp), intent(out) :: s(:)

    奇异值数组
    complex(kind=sp), intent(out), 可选的， target :: u(:,:)

    U的列包含左侧奇异向量
    complex(kind=sp), intent(out), 可选的， target :: vt(:,:)

    V^T的行包含右侧奇异向量
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] 可以覆盖和销毁 A 数据吗？
    logical(kind=lk), intent(in), optional :: full_matrices

    [可选] 完整矩阵的形状(u)==[m,m]，形状(vh)==[n,n]（默认）；否则，它们为形状(u)==[m,k]和形状(vh)==[k,n]，其中k=min(m,n)
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • 私有模块子程序 stdlib_linalg_svd_d(a, s, u, vt, overwrite_a, full_matrices, err)

    摘要

    计算矩阵的奇异值分解

    描述

    此函数计算real或complex矩阵的奇异值分解，并返回奇异值数组，以及可选的左侧矩阵包含左侧酉奇异向量，以及右侧矩阵，包含右侧酉奇异向量。

    参数：a 输入大小为[m,n]的矩阵。参数：s 输出大小为[min(m,n)]的real数组，返回奇异值列表。参数：u [可选] 输出大小为[m,m]或[m,min(m,n)]（.not.full_matrices）的左侧奇异矩阵。包含奇异向量作为列。参数：vt [可选] 输出大小为[n,n]或[min(m,n),n]（.not.full_matrices）的右侧奇异矩阵。包含奇异向量作为行。
    参数：overwrite_a [可选] 指示是否可以覆盖输入矩阵的标志。参数：full_matrices [可选] 如果为.true.（默认），则矩阵和的大小为[m,m]，[n,n]。否则，它们为[m,k]，[k,n]，其中k=min(m,n)。参数：err [可选] 状态返回标志。

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(inout), target :: a(:,:)

    输入矩阵 A[m,n]
    real(kind=dp), intent(out) :: s(:)

    奇异值数组
    real(kind=dp), intent(out), 可选的， target :: u(:,:)

    U的列包含左侧奇异向量
    real(kind=dp), intent(out), 可选的， target :: vt(:,:)

    V^T的行包含右侧奇异向量
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] 可以覆盖和销毁 A 数据吗？
    logical(kind=lk), intent(in), optional :: full_matrices

    [可选] 完整矩阵的形状(u)==[m,m]，形状(vh)==[n,n]（默认）；否则，它们为形状(u)==[m,k]和形状(vh)==[k,n]，其中k=min(m,n)
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • 私有模块子程序 stdlib_linalg_svd_s(a, s, u, vt, overwrite_a, full_matrices, err)

    摘要

    计算矩阵的奇异值分解

    描述

    此函数计算real或complex矩阵的奇异值分解，并返回奇异值数组，以及可选的左侧矩阵包含左侧酉奇异向量，以及右侧矩阵，包含右侧酉奇异向量。

    参数：a 输入大小为[m,n]的矩阵。参数：s 输出大小为[min(m,n)]的real数组，返回奇异值列表。参数：u [可选] 输出大小为[m,m]或[m,min(m,n)]（.not.full_matrices）的左侧奇异矩阵。包含奇异向量作为列。参数：vt [可选] 输出大小为[n,n]或[min(m,n),n]（.not.full_matrices）的右侧奇异矩阵。包含奇异向量作为行。
    参数：overwrite_a [可选] 指示是否可以覆盖输入矩阵的标志。参数：full_matrices [可选] 如果为.true.（默认），则矩阵和的大小为[m,m]，[n,n]。否则，它们为[m,k]，[k,n]，其中k=min(m,n)。参数：err [可选] 状态返回标志。

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(inout), target :: a(:,:)

    输入矩阵 A[m,n]
    real(kind=sp), intent(out) :: s(:)

    奇异值数组
    real(kind=sp), intent(out), 可选的， target :: u(:,:)

    U的列包含左侧奇异向量
    real(kind=sp), intent(out), 可选的， target :: vt(:,:)

    V^T的行包含右侧奇异向量
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] 可以覆盖和销毁 A 数据吗？
    logical(kind=lk), intent(in), optional :: full_matrices

    [可选] 完整矩阵的形状(u)==[m,m]，形状(vh)==[n,n]（默认）；否则，它们为形状(u)==[m,k]和形状(vh)==[k,n]，其中k=min(m,n)
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

  • 私有模块子程序 stdlib_linalg_svd_z(a, s, u, vt, overwrite_a, full_matrices, err)

    摘要

    计算矩阵的奇异值分解

    描述

    此函数计算real或complex矩阵的奇异值分解，并返回奇异值数组，以及可选的左侧矩阵包含左侧酉奇异向量，以及右侧矩阵，包含右侧酉奇异向量。

    参数：a 输入大小为[m,n]的矩阵。参数：s 输出大小为[min(m,n)]的real数组，返回奇异值列表。参数：u [可选] 输出大小为[m,m]或[m,min(m,n)]（.not.full_matrices）的左侧奇异矩阵。包含奇异向量作为列。参数：vt [可选] 输出大小为[n,n]或[min(m,n),n]（.not.full_matrices）的右侧奇异矩阵。包含奇异向量作为行。
    参数：overwrite_a [可选] 指示是否可以覆盖输入矩阵的标志。参数：full_matrices [可选] 如果为.true.（默认），则矩阵和的大小为[m,m]，[n,n]。否则，它们为[m,k]，[k,n]，其中k=min(m,n)。参数：err [可选] 状态返回标志。

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(inout), target :: a(:,:)

    输入矩阵 A[m,n]
    real(kind=dp), intent(out) :: s(:)

    奇异值数组
    complex(kind=dp), intent(out), 可选的， target :: u(:,:)

    U的列包含左侧奇异向量
    complex(kind=dp), intent(out), 可选的， target :: vt(:,:)

    V^T的行包含右侧奇异向量
    logical(kind=lk), intent(in), optional :: overwrite_a

    [可选] 可以覆盖和销毁 A 数据吗？
    logical(kind=lk), intent(in), optional :: full_matrices

    [可选] 完整矩阵的形状(u)==[m,m]，形状(vh)==[n,n]（默认）；否则，它们为形状(u)==[m,k]和形状(vh)==[k,n]，其中k=min(m,n)
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

公共接口 svdvals

计算real或complex二维矩阵的奇异值。（规范）

摘要

计算real或complex二维矩阵的奇异值分解的奇异值数组的函数接口。

描述

此接口提供计算二维矩阵奇异值的方法。支持的数据类型包括real和complex。该函数返回一个real类型的奇异值数组，大小为[min(m,n)]。

注意

该解决方案基于LAPACK的奇异值分解*GESDD方法。

示例

    real(sp) :: a(2,3), s(2)
    a = reshape([3,2, 2,3, 2,-2],[2,3])

    s = svdvals(A)
    print *, 'singular values = ',s

  • 私有模块函数 stdlib_linalg_svdvals_c(a, err) result(s)

    摘要

    计算奇异值来自矩阵的奇异值分解.

    描述

    此函数返回来自real或complex矩阵的奇异值分解的奇异值数组.

    参数：a 输入大小为[m,n]的矩阵。参数：err [可选] 状态返回标志。

    返回值

    参数：s 大小为[min(m,n)]的real数组，返回奇异值列表。

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(in), target :: a(:,:)

    输入矩阵 A[m,n]
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

    返回值 real(kind=sp), allocatable, (:)

    奇异值数组

  • 私有模块函数 stdlib_linalg_svdvals_d(a, err) result(s)

    摘要

    计算奇异值来自矩阵的奇异值分解.

    描述

    此函数返回来自real或complex矩阵的奇异值分解的奇异值数组.

    参数：a 输入大小为[m,n]的矩阵。参数：err [可选] 状态返回标志。

    返回值

    参数：s 大小为[min(m,n)]的real数组，返回奇异值列表。

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(in), target :: a(:,:)

    输入矩阵 A[m,n]
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

    返回值 real(kind=dp), allocatable, (:)

    奇异值数组

  • 私有模块函数 stdlib_linalg_svdvals_s(a, err) result(s)

    摘要

    计算奇异值来自矩阵的奇异值分解.

    描述

    此函数返回来自real或complex矩阵的奇异值分解的奇异值数组.

    参数：a 输入大小为[m,n]的矩阵。参数：err [可选] 状态返回标志。

    返回值

    参数：s 大小为[min(m,n)]的real数组，返回奇异值列表。

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(in), target :: a(:,:)

    输入矩阵 A[m,n]
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

    返回值 real(kind=sp), allocatable, (:)

    奇异值数组

  • 私有模块函数 stdlib_linalg_svdvals_z(a, err) result(s)

    摘要

    计算奇异值来自矩阵的奇异值分解.

    描述

    此函数返回来自real或complex矩阵的奇异值分解的奇异值数组.

    参数：a 输入大小为[m,n]的矩阵。参数：err [可选] 状态返回标志。

    返回值

    参数：s 大小为[min(m,n)]的real数组，返回奇异值列表。

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(in), target :: a(:,:)

    输入矩阵 A[m,n]
    type(linalg_state_type), intent(out), optional :: err

    [可选] 状态返回值标志。如果未请求错误，则代码将停止

    返回值 real(kind=dp), allocatable, (:)

    奇异值数组

公共接口 trace

计算矩阵的迹。（规范）

  • 私有函数 trace_rsp(A) result(res)

    参数

    类型 意图可选 属性 名称
    real(kind=sp), intent(in) :: A(:,:)

    返回值 real(kind=sp)

  • 私有函数 trace_rdp(A) result(res)

    参数

    类型 意图可选 属性 名称
    real(kind=dp), intent(in) :: A(:,:)

    返回值 real(kind=dp)

  • 私有函数 trace_csp(A) result(res)

    参数

    类型 意图可选 属性 名称
    complex(kind=sp), intent(in) :: A(:,:)

    返回值 complex(kind=sp)

  • 私有函数 trace_cdp(A) result(res)

    参数

    类型 意图可选 属性 名称
    complex(kind=dp), intent(in) :: A(:,:)

    返回值 complex(kind=dp)

  • 私有函数 trace_iint8(A) result(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int8), intent(in) :: A(:,:)

    返回值 integer(kind=int8)

  • 私有函数 trace_iint16(A) result(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int16), intent(in) :: A(:,:)

    返回值 integer(kind=int16)

  • 私有函数 trace_iint32(A) result(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int32), intent(in) :: A(:,:)

    返回值 integer(kind=int32)

  • 私有函数 trace_iint64(A) result(res)

    参数

    类型 意图可选 属性 名称
    integer(kind=int64), intent(in) :: A(:,:)

    返回值 integer(kind=int64)


函数

公共纯函数 eye(dim1, dim2) result(result)

许可证
Creative Commons License
版本
实验性

构造单位矩阵。（规范）

参数

类型 意图可选 属性 名称
integer, intent(in) :: dim1
integer, intent(in), optional :: dim2

返回值 integer(kind=int8), allocatable, (:,:)