程序

左对齐字符串表示的字符序列。 字符序列的长度保持不变。

右对齐字符串表示的字符序列。 字符序列的长度保持不变。

返回一个布尔标量，其中两个数组在公差范围内逐元素相等。 (规范)

将set1中的位设置为set1和set2中原始位的按位and。 这些集合必须具有相同数量的位，否则结果未定义。 (规范)

将set1中的位设置为set1中原始位的按位与，并与set2的按位否定相与。 这些集合必须具有相同数量的位，否则结果未定义。

arange创建一个一维array，其类型为integer/real，具有给定间距的固定间距值，位于给定区间内。 (规范)

arg计算区间 (-π,π] 内的相位角。 (规范)

(规范)

argd计算区间 (-180.0,180.0] 内的度数版本的相位角。 (规范)

argpi计算区间 (-1.0,1.0] 内的圆形版本的相位角。 (规范)

将字符序列赋给字符串。

用于为bitset_large定义赋值。 (规范)

AXPY 常数乘以向量加上向量。

返回一个stringlist_index_type类型的实例，表示反向索引规范

返回self中的位位置数量。

版本实验

正态分布累积分布函数 (规范)

获取整数、实数和复数变量的均匀分布累积分布函数 (cdf)。 (规范)

返回字符串表示的字符序列。

检查逻辑条件的值 (规范)

计算 Cholesky 分解$A = L \cdot L^T$或$A = U^T \cdot U$。 (规范)

计算 Cholesky 分解$A = L \cdot L^T$或$A = U^T \cdot U$。 (规范)

从字符串中删除尾随字符集。 如果没有提供字符集，则删除尾随空格。

COPY 将向量 x 复制到向量 y。

将键 old_key 的内容复制到键 new_key (规范)

将其他数据 other_in 复制到变量 other_out (规范)

数组元素的皮尔逊相关性 (规范)

返回子字符串 'pattern' 在输入字符串 'string' 中出现的次数 规范

数组元素的协方差 (规范)

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

deg2rad将相位角从度数转换为弧度。 (规范)

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

创建对角数组或提取数组的对角元素 (规范)

计算数组中相邻元素之间的差值。 (规范)

版本实验

一阶导数勒让德多项式

DOT 形成两个向量的点积。 对增量等于 1 使用展开循环。

DOTC 形成两个复数向量的点积 DOTC = X^H * Y

DOTU 形成两个复数向量的点积 DOTU = X^T * Y

求解特征分解$A \cdot \bar{v} - \lambda \cdot \bar{v}$对于方阵$A$。 (规范)

求解特征分解$A \cdot \bar{v} - \lambda \cdot \bar{v}$对于实对称$A = A^T$或复厄米$A = A^H$方阵。 (规范)

返回特征值$lambda$, $A \cdot \bar{v} - \lambda \cdot \bar{v}$，对于方阵$A$。 (规范)

返回特征值$lambda$, $A \cdot \bar{v} - \lambda \cdot \bar{v}$，对于实对称$A = A^T$或复厄米$A = A^H$方阵。 (规范)

检查字符串是否以子字符串结尾

从位集old中的范围start_pos到stop_pos创建一个新的位集new。 如果start_pos大于stop_pos，则新的位集为空。 如果start_pos小于零或stop_pos大于bits(old)-1，则如果status存在，它具有值index_invalid_error，并且new未定义，否则处理将停止并显示一条信息性消息。 (规范)

构造单位矩阵。 (规范)

返回数组中假元素的位置。 规范

将 64 位整数key映射到一个无符号整数值，该值只有nbits位，其中nbits小于 64 (规范)

将 32 位整数key映射到一个无符号整数值，该值只有nbits位，其中nbits小于 32 (规范)

返回一个stringlist_index_type类型的实例，表示正向索引 规范

在输入 'string' 中查找子字符串 'pattern' 的起始索引 规范

FNV_1 接口 (规范)

FNV_1 接口 (规范)

使用 FNV_1 算法对键进行哈希处理 参数：key - 要进行哈希处理的键

FNV_1A 接口 (规范)

FNV_1A 接口 (规范)

使用 FNV_1a 算法对键进行哈希处理 (规范)

释放键中的内存 (规范)

释放其他数据中的内存 (规范)

整数和复数的伽马函数

计算高斯-勒让德求积节点和权重。

计算高斯-勒让德-洛巴托求积节点和权重。

GBMV 执行以下矩阵-向量运算之一 y := alphaAx + betay，或 y := alphaATx + betay，或 y := alpha*AHx + betay，其中 alpha 和 beta 是标量，x 和 y 是向量，A 是一个 m 行 n 列带状矩阵，具有 kl 个子对角线和 ku 个超对角线。

返回两个整数的最大公约数 (规范)

GEMM 执行以下矩阵-矩阵运算之一 C := alphaop( A )op( B ) + betaC，其中 op( X ) 是以下运算之一 op( X ) = X 或 op( X ) = XT 或 op( X ) = X*H，alpha 和 beta 是标量，A、B 和 C 是矩阵，其中 op( A ) 是一个 m 行 k 列矩阵，op( B ) 是一个 k 行 n 列矩阵，C 是一个 m 行 n 列矩阵。

GEMV 执行以下矩阵-向量运算之一 y := alphaAx + betay，或 y := alphaATx + betay，或 y := alpha*AHx + betay，其中 alpha 和 beta 是标量，x 和 y 是向量，A 是一个 m 行 n 列矩阵。

GER 执行秩 1 运算 A := alphaxy**T + A，其中 alpha 是一个标量，x 是一个 m 元素向量，y 是一个 n 元素向量，A 是一个 m 行 n 列矩阵。

GERC 执行秩 1 运算 A := alphaxy**H + A，其中 alpha 是一个标量，x 是一个 m 元素向量，y 是一个 n 元素向量，A 是一个 m 行 n 列矩阵。

GERU 执行秩 1 运算 A := alphaxy**T + A，其中 alpha 是一个标量，x 是一个 m 元素向量，y 是一个 n 元素向量，A 是一个 m 行 n 列矩阵。

获取函数以检索标准库版本

从格式化的单元中读取整行到字符串变量

HBMV 执行矩阵-向量运算 y := alphaAx + beta*y，其中 alpha 和 beta 是标量，x 和 y 是 n 元素向量，A 是一个 n 行 n 列厄米特带状矩阵，具有 k 个超对角线。

HEMM 执行以下矩阵-矩阵运算之一 C := alphaAB + betaC，或 C := alphaBA + betaC，其中 alpha 和 beta 是标量，A 是一个厄米特矩阵，B 和 C 是 m 行 n 列矩阵。

HEMV 执行矩阵向量运算 y := alpha * A * x + beta * y，其中 alpha 和 beta 是标量，x 和 y 是 n 元向量，A 是一个 n×n 厄米矩阵。

HER 执行厄米秩 1 运算 A := alpha * x * x**H + A，其中 alpha 是一个实数标量，x 是一个 n 元向量，A 是一个 n×n 厄米矩阵。

HER2 执行厄米秩 2 运算 A := alpha * x * y**H + conjg( alpha ) * y * x**H + A，其中 alpha 是一个标量，x 和 y 是 n 元向量，A 是一个 n×n 厄米矩阵。

HER2K 执行一个厄米秩 2k 运算 C := alpha * A * B**H + conjg( alpha ) * B * A**H + beta * C，或 C := alpha * A**H * B + conjg( alpha ) * B**H * A + beta * C，其中 alpha 和 beta 是标量，beta 为实数，C 是一个 n×n 厄米矩阵，A 和 B 在第一种情况下是 n×k 矩阵，在第二种情况下是 k×n 矩阵。

HERK 执行一个厄米秩 k 运算 C := alpha * A * A**H + beta * C，或 C := alpha * A**H * A + beta * C，其中 alpha 和 beta 是实数标量，C 是一个 n×n 厄米矩阵，A 在第一种情况下是 n×k 矩阵，在第二种情况下是 k×n 矩阵。

HPMV 执行矩阵向量运算 y := alpha * A * x + beta * y，其中 alpha 和 beta 是标量，x 和 y 是 n 元向量，A 是一个 n×n 厄米矩阵，以压缩形式提供。

HPR 执行厄米秩 1 运算 A := alpha * x * x**H + A，其中 alpha 是一个实数标量，x 是一个 n 元向量，A 是一个 n×n 厄米矩阵，以压缩形式提供。

HPR2 执行厄米秩 2 运算 A := alpha * x * y**H + conjg( alpha ) * y * x**H + A，其中 alpha 是一个标量，x 和 y 是 n 元向量，A 是一个 n×n 厄米矩阵，以压缩形式提供。

ASCII 排序序列中的代码。

字符到整数转换函数。

子串在字符串中的位置。

方阵的逆 (规范)

方阵的求逆 (规范)

检查 c 是否为 ASCII 字母（A .. Z，a .. z）。

检查 c 是否为字母或数字（0 .. 9，a .. z，A .. Z）。

检查 c 是否在 ASCII 字符集中 - 即在 0 .. 0x7F 范围内。

检查 c 是否为空格字符。这仅包括空格和制表符。

返回一个布尔标量/数组，其中两个标量/数组在公差范围内按元素相等。(规范)

检查 c 是否为控制字符。

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

检查 c 是否为数字（0 .. 9）。

检查 c 是否为除空格字符以外的可打印字符。

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

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

检查 c 是否为 16 进制数字（0 .. 9，A .. F，a .. f）。

检查 c 是否为小写 ASCII 字母（a .. z）。

检查 c 是否为 8 进制数字（0 .. 7）。

检查 c 是否为可打印字符 - 包括空格字符。

检查 c 是否为标点符号字符。这包括所有 ASCII 字符，这些字符不是控制字符、字母、数字或空格。

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

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

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

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

检查 c 是否为大写 ASCII 字母（A .. Z）。

检查 c 是否为空格字符。这包括空格、制表符、垂直制表符、换页符、回车符和换行符。

计算两个大小为 M1xN1 和 M2xN2 的数组的克罗内克积，返回一个 (M1*M2)x(N1*N2) 数组 (规范)

勒让德多项式

返回字符串表示的字符序列的长度。

返回字符串表示的字符序列的长度，不包括尾随空格。

按字典顺序比较两个字符序列，大于等于，左侧、右侧或两个字符序列都可以用字符串表示。

按字典顺序比较两个字符序列，大于，左侧、右侧或两个字符序列都可以用字符串表示。

流程控制：在输出标志存在的情况下，返回它；否则，在发生错误时停止。

创建线性间隔元素的秩 1 数组 如果未指定元素数，则创建一个大小为 100 的数组。如果 n 为负值，则返回大小为 0 的数组。如果 n = 1，则返回一个数组，其唯一元素为 end (规范)

按字典顺序比较两个字符序列，小于等于，左侧、右侧或两个字符序列都可以用字符串表示。

按字典顺序比较两个字符序列，小于，左侧、右侧或两个字符序列都可以用字符串表示。

加载 npy 格式的多维数组 (规范)

从文本文件加载 2D 数组 (规范)

n! 的对数，整数变量

伽马函数的对数

下不完全伽马函数的对数

上不完全伽马函数的对数

创建从 base**start 到 base**end 对数间隔元素的秩 1 数组。如果未指定元素数，则创建一个大小为 50 的数组。如果 n 为负值，则返回大小为 0 的数组。如果 n = 1，则返回一个数组，其唯一元素为 base**end。如果没有指定 base，logspace 将默认为使用 base 10

下不完全伽马函数

计算系统$A \cdot x = b$的平方解。 (规范)

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

数组元素的平均值 (规范)

数组元素的中位数 (规范)

从坐标向量计算坐标矩阵列表。 (规范)

数组元素的中心矩 (规范)

将分配的字符标量从 'from' 移动到 'to' 规范

(规范

(规范)

(规范)

NMHASH32 接口 (规范)

NMHASH32X 接口 (规范)

NRM2 通过函数名称返回向量的欧几里得范数，因此 NRM2 := sqrt( x'*x )

返回一个 64 位伪随机整数 harvest，它在 64 位类型的所有奇数整数上均匀分布。(规范)

返回一个 32 位伪随机整数 harvest，它在 int32 类型的奇数整数上均匀分布。(规范)

打开文件 (规范)

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

方阵的逆运算符 (规范)

将字符串列表与输入实体连接起来 返回一个新的字符串列表 规范

连接两个字符序列，左侧、右侧或两个字符序列都可以用字符串表示。

将字符串列表与输入实体进行不相等比较 返回一个逻辑值 规范

比较两个字符序列是否不相等，左侧、右侧或两个字符序列都可以用字符串表示。

如果 set1 和 set2 中的所有位的值不都相同，则返回 .true.，否则返回 .false.。这些集合必须具有相同数量的位，否则结果是未定义的。(规范)

比较两个字符序列是否小于，左侧、右侧或两个字符序列都可以用字符串表示。

如果set1和set2中的位不同，并且最高位的不同位在set1中设置为0，在set2中设置为1，则返回.true.，否则返回.false.。集合必须具有相同数量的位，否则结果未定义。 (规范)

比较两个字符序列是否小于，左侧，右侧或两个字符序列都可以用字符串表示。

如果set1和set2中的位相同或最高位的不同位在set1中设置为0，在set2中设置为1，则返回.true.，否则返回.false.。集合必须具有相同数量的位，否则结果未定义。 (规范)

比较字符串列表与输入实体是否相等，返回一个逻辑值 规范

比较两个字符序列是否相等，左侧，右侧或两个字符序列都可以用字符串表示。

比较运算符

如果set1和set2中的所有位都具有相同的值，则返回.true.，否则返回.false.。集合必须具有相同数量的位，否则结果未定义。 (规范)

比较两个字符序列是否大于，左侧，右侧或两个字符序列都可以用字符串表示。

如果set1和set2中的位不同，并且最高位的不同位在set1中设置为1，在set2中设置为0，则返回.true.，否则返回.false.。集合必须具有相同数量的位，否则结果未定义。 (规范)

比较两个字符序列是否大于，左侧，右侧或两个字符序列都可以用字符串表示。

如果set1和set2中的位相同或最高位的不同位在set1中设置为1，在set2中设置为0，则返回.true.，否则返回.false.。集合必须具有相同数量的位，否则结果未定义。 (规范)

可选参数的回退值 (规范)

将set1中的位设置为set1和set2中原始位的按位或。集合必须具有相同数量的位，否则结果未定义。 (规范)

实现ORD_SORT算法的通用子程序接口，该算法是"Rust" sort算法（在slice.rs中找到）的Fortran 2008翻译 https://github.com/rust-lang/rust/blob/90eb44a5897c39e3dff9c7e48e3973671dcd9496/src/liballoc/slice.rs#L2159 ORD_SORT是一种混合稳定比较算法，它结合了合并排序和插入排序。 (规范)

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

在输入字符串的左侧填充 规范

在输入字符串的右侧填充 规范

版本实验

正态分布概率密度函数 (规范)

获取整数，实数和复数变量的均匀分布概率密度（pdf）。 (规范)

PENGY_HASH 接口 (规范)

rad2deg将相位角从弧度转换为度数。 (规范)

实现LSD基数排序算法的通用子程序接口，有关详细信息，请参见https://en.wikipedia.org/wiki/Radix_sort。它始终对随机数据进行O(N)排序，但需要O(N)缓冲区。 (规范)

版本实验

从连接的非格式化单元读取字符序列到字符串中。

从连接的非格式化单元读取字符序列到字符串中。

正则化（归一化）下不完全伽玛函数，P

正则化（归一化）上不完全伽玛函数，Q

将字符串持有的字符序列重复指定数量的副本。

将输入'string'中所有出现的子字符串'pattern'替换为替换'replacement' 版本：实验性

反转输入字符串持有的字符序列

反转输入字符变量中的字符顺序 (规范)

ROT应用平面旋转。

计算使用公式 |x| = sqrt( Re(x)2 + Im(x)2 ) sgn(x) = x / |x| 如果 x /= 0 = 1 如果 x = 0 c = |a| / sqrt(|a|2 + |b|2) s = sgn(a) * conjg(b) / sqrt(|a|2 + |b|2) 当a和b为实数且r /= 0时，公式简化为 r = sgn(a)sqrt(|a|2 + |b|*2) c = a / r s = b / r 与SROTG中|a| > |b|时相同。当|b| >= |a|时，如果a和b的符号不同，则c和s的符号将不同于SROTG计算出的符号。

ROTM应用修改后的Givens变换，$H$到2×N矩阵 $$\left[ \begin{array}{c}DX^T\\DY^T\\ \end{array} \right],$$ 其中$^T$表示转置。元素$DX$位于DX(LX+IINCX), I = 0:N-1，其中LX = 1如果INCX >= 0，否则LX = (-INCX)N，对于DY使用LY和INCY类似。使用DPARAM(1)=DFLAG，$H$具有以下形式之一 $$H=\underbrace{\begin{bmatrix}DH_{11} & DH_{12}\\DH_{21} & DH_{22}\end{bmatrix}}_{DFLAG=-1}, \underbrace{\begin{bmatrix}1 & DH_{12}\\DH_{21} & 1\end{bmatrix}}_{DFLAG=0}, \underbrace{\begin{bmatrix}DH_{11} & 1\\-1 & DH_{22}\end{bmatrix}}_{DFLAG=1}, \underbrace{\begin{bmatrix}1 & 0\\0 & 1\end{bmatrix}}_{DFLAG=-2}.$$
有关DPARAM中数据存储的描述，请参见ROTMG。

ROTMG构建修改后的Givens变换矩阵$H$它将2向量 $$\left[ {\sqrt{DD_1}\cdot DX_1,\sqrt{DD_2}\cdot DY_2} \right]^T.$$ 的第二部分归零。使用DPARAM(1)=DFLAG，$H$具有以下形式之一
$$H=\underbrace{\begin{bmatrix}DH_{11} & DH_{12}\\DH_{21} & DH_{22}\end{bmatrix}}_{DFLAG=-1}, \underbrace{\begin{bmatrix}1 & DH_{12}\\DH_{21} & 1\end{bmatrix}}_{DFLAG=0}, \underbrace{\begin{bmatrix}DH_{11} & 1\\-1 & DH_{22}\end{bmatrix}}_{DFLAG=1}, \underbrace{\begin{bmatrix}1 & 0\\0 & 1\end{bmatrix}}_{DFLAG=-2}.$$ DPARAM的第2-4个位置分别包含DH11、DH21、DH12和DH22。（DPARAM(1)的值隐含的1.0、-1.0或0.0的值不会存储在DPARAM中。）参数GAMSQ和RGAMSQ的值可能不精确。这没关系，因为它们仅用于测试DD1和DD2的大小。所有实际的数据缩放都是使用GAM完成的。

版本实验

正态分布随机变量 (规范)

获取整数，实数和复数变量的均匀分布随机变量。 (规范)

将多维数组保存为npy格式 (规范)

将2D数组保存到文本文件中 (规范)

SBMV执行矩阵向量运算 y := alphaAx + beta*y，其中alpha和beta是标量，x和y是n个元素向量，A是n×n对称带状矩阵，具有k个超对角线。

SCAL按常数缩放向量。

扫描字符串中是否存在一组字符。扫描字符串中是否存在一组字符中的任何字符。

计算两个向量的内积，并使用扩展精度累积结果。返回D.P.点积，在D.P.中累积，对于S.P. SX和SY SDOT = sum for I = 0 to N-1 of SX(LX+IINCX) * SY(LY+IINCY)，其中LX = 1如果INCX >= 0，否则LX = 1+(1-N)*INCX，LY使用INCY类似定义。

使用NMHASH32散列算法散列密钥 (规范)

使用NMHASH32X散列算法散列密钥 (规范) 参数：key - 要散列的密钥 seed - 散列算法的种子（未使用）

使用waterhash算法散列密钥 (规范)

(规范)

整数、实数和复数变量的秩为一的数组的Fisher-Yates洗牌算法。 (规范)

使用辛普森规则对采样值进行积分 (规范)

使用给定横坐标的梯形规则权重对采样值进行积分 (规范)

从输入字符串中提取字符以返回一个新字符串

求解线性系统$A \cdot x = b$以求解未知向量$x$从方阵$A$. (规范)

计算系统$A \cdot x = b$. (规范)

求解线性系统$A \cdot x = b$以求解未知向量$x$从方阵$A$. (规范)

实现SORT算法的通用子程序接口，该算法基于David Musser的introsort。 (规范)

实现SORT_INDEX算法的通用子程序接口，该算法基于在slice.rs中找到的"Rust" sort算法 https://github.com/rust-lang/rust/blob/90eb44a5897c39e3dff9c7e48e3973671dcd9496/src/liballoc/slice.rs#L2159，但进行了修改以返回一个索引数组，该数组将提供秩为一的ARRAY输入的稳定排序。 (规范)

SPMV执行矩阵向量运算 y := alphaAx + beta*y，其中alpha和beta是标量，x和y是n个元素向量，A是n×n对称矩阵，以压缩形式提供。

SPOOKY_HASH 接口 (规范)

SPR执行对称秩1运算 A := alphaxx**T + A，其中alpha是实数标量，x是n个元素向量，A是n×n对称矩阵，以压缩形式提供。

SPR2执行对称秩2运算 A := alphaxyT + alphayxT + A，其中alpha是标量，x和y是n个元素向量，A是n×n对称矩阵，以压缩形式提供。

SROT应用平面旋转，其中cos和sin（c和s）为实数，向量cx和cy为复数。 jack dongarra, linpack, 3/11/78.

SSCAL按实数常数缩放复数向量。

检查字符串是否以子字符串开头

CAXPY 常数乘以向量加上向量。

CCOPY 将向量x复制到向量y。

CDOTC 计算两个复向量之间的点积 CDOTC = X^H * Y

CDOTU 计算两个复向量之间的点积 CDOTU = X^T * Y

CGBMV 执行以下矩阵向量运算之一：y := alpha * A * x + beta * y, 或 y := alpha * A^T * x + beta * y, 或 y := alpha * A^H * x + beta * y，其中 alpha 和 beta 是标量，x 和 y 是向量，A 是一个 m 行 n 列的带状矩阵，具有 kl 个次对角线和 ku 个超对角线。

CGEMM 执行以下矩阵矩阵运算之一：C := alpha * op( A ) * op( B ) + beta * C，其中 op( X ) 是以下之一：op( X ) = X 或 op( X ) = X^T 或 op( X ) = X^H，alpha 和 beta 是标量，A、B 和 C 是矩阵，其中 op( A ) 是一个 m 行 k 列矩阵，op( B ) 是一个 k 行 n 列矩阵，而 C 是一个 m 行 n 列矩阵。

CGEMV 执行以下矩阵向量运算之一：y := alpha * A * x + beta * y, 或 y := alpha * A^T * x + beta * y, 或 y := alpha * A^H * x + beta * y，其中 alpha 和 beta 是标量，x 和 y 是向量，A 是一个 m 行 n 列矩阵。

CGERC 执行秩 1 运算 A := alpha * x * y^H + A，其中 alpha 是一个标量，x 是一个 m 元素向量，y 是一个 n 元素向量，而 A 是一个 m 行 n 列矩阵。

CGERU 执行秩 1 运算 A := alpha * x * y^T + A，其中 alpha 是一个标量，x 是一个 m 元素向量，y 是一个 n 元素向量，而 A 是一个 m 行 n 列矩阵。

CHBMV 执行矩阵向量运算 y := alpha * A * x + beta * y，其中 alpha 和 beta 是标量，x 和 y 是 n 元素向量，A 是一个 n 行 n 列的埃尔米特带状矩阵，具有 k 个超对角线。

CHEMM 执行以下矩阵矩阵运算之一：C := alpha * A * B + beta * C, 或 C := alpha * B * A + beta * C，其中 alpha 和 beta 是标量，A 是一个埃尔米特矩阵，而 B 和 C 是 m 行 n 列矩阵。

CHEMV 执行矩阵向量运算 y := alpha * A * x + beta * y，其中 alpha 和 beta 是标量，x 和 y 是 n 元素向量，A 是一个 n 行 n 列的埃尔米特矩阵。

CHER 执行埃尔米特秩 1 运算 A := alpha * x * x^H + A，其中 alpha 是一个实数标量，x 是一个 n 元素向量，而 A 是一个 n 行 n 列的埃尔米特矩阵。

CHER2 执行埃尔米特秩 2 运算 A := alpha * x * y^H + conjg( alpha ) * y * x^H + A，其中 alpha 是一个标量，x 和 y 是 n 元素向量，而 A 是一个 n 行 n 列的埃尔米特矩阵。

CHER2K 执行以下埃尔米特秩 2k 运算之一：C := alpha * A * B^H + conjg( alpha ) * B * A^H + beta * C, 或 C := alpha * A^H * B + conjg( alpha ) * B^H * A + beta * C，其中 alpha 和 beta 是标量，beta 是实数，C 是一个 n 行 n 列的埃尔米特矩阵，而 A 和 B 是第一种情况下为 n 行 k 列矩阵，第二种情况下为 k 行 n 列矩阵。

CHERK 执行以下埃尔米特秩 k 运算之一：C := alpha * A * A^H + beta * C, 或 C := alpha * A^H * A + beta * C，其中 alpha 和 beta 是实数标量，C 是一个 n 行 n 列的埃尔米特矩阵，而 A 是第一种情况下为 n 行 k 列矩阵，第二种情况下为 k 行 n 列矩阵。

CHPMV 执行矩阵向量运算 y := alpha * A * x + beta * y，其中 alpha 和 beta 是标量，x 和 y 是 n 元素向量，A 是一个 n 行 n 列的埃尔米特矩阵，以打包形式提供。

CHPR 执行埃尔米特秩 1 运算 A := alpha * x * x^H + A，其中 alpha 是一个实数标量，x 是一个 n 元素向量，而 A 是一个 n 行 n 列的埃尔米特矩阵，以打包形式提供。

CHPR2 执行埃尔米特秩 2 运算 A := alpha * x * y^H + conjg( alpha ) * y * x^H + A，其中 alpha 是一个标量，x 和 y 是 n 元素向量，而 A 是一个 n 行 n 列的埃尔米特矩阵，以打包形式提供。

计算使用公式 |x| = sqrt( Re(x)2 + Im(x)2 ) sgn(x) = x / |x| 如果 x /= 0 = 1 如果 x = 0 c = |a| / sqrt(|a|2 + |b|2) s = sgn(a) * conjg(b) / sqrt(|a|2 + |b|2) 当a和b为实数且r /= 0时，公式简化为 r = sgn(a)sqrt(|a|2 + |b|*2) c = a / r s = b / r 与SROTG中|a| > |b|时相同。当|b| >= |a|时，如果a和b的符号不同，则c和s的符号将不同于SROTG计算出的符号。

CSCAL 用常数缩放向量。

CSROT 应用平面旋转，其中 cos 和 sin（c 和 s）是实数，而向量 cx 和 cy 是复数。jack dongarra，linpack，3/11/78。

CSSCAL 用实数常数缩放复向量。

CSWAP 交换两个向量。

CSYMM 执行以下矩阵矩阵运算之一：C := alpha * A * B + beta * C, 或 C := alpha * B * A + beta * C，其中 alpha 和 beta 是标量，A 是一个对称矩阵，而 B 和 C 是 m 行 n 列矩阵。

CSYR2K 执行以下对称秩 2k 运算之一：C := alpha * A * B^T + alpha * B * A^T + beta * C, 或 C := alpha * A^T * B + alpha * B^T * A + beta * C，其中 alpha 和 beta 是标量，C 是一个 n 行 n 列的对称矩阵，而 A 和 B 是第一种情况下为 n 行 k 列矩阵，第二种情况下为 k 行 n 列矩阵。

CSYRK 执行以下对称秩 k 运算之一：C := alpha * A * A^T + beta * C, 或 C := alpha * A^T * A + beta * C，其中 alpha 和 beta 是标量，C 是一个 n 行 n 列的对称矩阵，而 A 是第一种情况下为 n 行 k 列矩阵，第二种情况下为 k 行 n 列矩阵。

CTBMV 执行以下矩阵向量运算之一：x := A * x, 或 x := A^T * x, 或 x := A^H * x，其中 x 是一个 n 元素向量，A 是一个 n 行 n 列的单位或非单位上三角带状矩阵，具有 ( k + 1 ) 个对角线。

CTBSV 求解以下方程组之一：A * x = b, 或 A^T * x = b, 或 A^H * x = b，其中 b 和 x 是 n 元素向量，A 是一个 n 行 n 列的单位或非单位上三角带状矩阵，具有 ( k + 1 ) 个对角线。此例程中不包含奇异性或近似奇异性的测试。此类测试必须在调用此例程之前进行。

CTPMV 执行以下矩阵向量运算之一：x := A * x, 或 x := A^T * x, 或 x := A^H * x，其中 x 是一个 n 元素向量，A 是一个 n 行 n 列的单位或非单位上三角矩阵，以打包形式提供。

CTPSV 求解以下方程组之一：A * x = b, 或 A^T * x = b, 或 A^H * x = b，其中 b 和 x 是 n 元素向量，A 是一个 n 行 n 列的单位或非单位上三角矩阵，以打包形式提供。此例程中不包含奇异性或近似奇异性的测试。此类测试必须在调用此例程之前进行。

CTRMM 执行以下矩阵矩阵运算之一：B := alpha * op( A ) * B, 或 B := alpha * B * op( A )，其中 alpha 是一个标量，B 是一个 m 行 n 列矩阵，A 是一个单位或非单位上三角矩阵，而 op( A ) 是以下之一：op( A ) = A 或 op( A ) = A^T 或 op( A ) = A^H。

CTRMV 执行以下矩阵向量运算之一：x := A * x, 或 x := A^T * x, 或 x := A^H * x，其中 x 是一个 n 元素向量，A 是一个 n 行 n 列的单位或非单位上三角矩阵。

CTRSM 求解以下矩阵方程之一：op( A ) * X = alpha * B, 或 X * op( A ) = alpha * B，其中 alpha 是一个标量，X 和 B 是 m 行 n 列矩阵，A 是一个单位或非单位上三角矩阵，而 op( A ) 是以下之一：op( A ) = A 或 op( A ) = A^T 或 op( A ) = A^H。矩阵 X 将被覆盖到 B 上。

CTRSV 求解以下方程组之一：A * x = b, 或 A^T * x = b, 或 A^H * x = b，其中 b 和 x 是 n 元素向量，A 是一个 n 行 n 列的单位或非单位上三角矩阵。此例程中不包含奇异性或近似奇异性的测试。此类测试必须在调用此例程之前进行。

DASUM 求绝对值的总和。

DAXPY 常数乘以向量加上向量。对于等于 1 的增量使用展开的循环。

DCOPY 将向量 x 复制到向量 y。对于等于 1 的增量使用展开的循环。

DDOT 计算两个向量的点积。对于等于 1 的增量使用展开的循环。

DGBMV 执行以下矩阵向量运算之一：y := alpha * A * x + beta * y, 或 y := alpha * A^T * x + beta * y，其中 alpha 和 beta 是标量，x 和 y 是向量，A 是一个 m 行 n 列的带状矩阵，具有 kl 个次对角线和 ku 个超对角线。

DGEMM 执行以下矩阵矩阵运算之一：C := alpha * op( A ) * op( B ) + beta * C，其中 op( X ) 是以下之一：op( X ) = X 或 op( X ) = X^T，alpha 和 beta 是标量，A、B 和 C 是矩阵，其中 op( A ) 是一个 m 行 k 列矩阵，op( B ) 是一个 k 行 n 列矩阵，而 C 是一个 m 行 n 列矩阵。

DGEMV 执行以下矩阵向量运算之一：y := alpha * A * x + beta * y, 或 y := alpha * A^T * x + beta * y，其中 alpha 和 beta 是标量，x 和 y 是向量，A 是一个 m 行 n 列矩阵。

DGER 执行秩 1 运算 A := alpha * x * y^T + A，其中 alpha 是一个标量，x 是一个 m 元素向量，y 是一个 n 元素向量，而 A 是一个 m 行 n 列矩阵。

DNRM2 通过函数名返回向量的欧几里得范数，使得 DNRM2 := sqrt( x' * x )

DROT 应用平面旋转。

计算使用公式 sigma = sgn(a) if |a| > |b| = sgn(b) if |b| >= |a| r = sigma * sqrt( a^2 + b^2 ) c = 1; s = 0 if r = 0 c = a/r; s = b/r if r != 0 子例程还计算 z = s if |a| > |b|, = 1/c if |b| >= |a| and c != 0 = 1 if c = 0 这允许根据 z 重构 c 和 s：如果 z = 1，则将 c 设置为 0，将 s 设置为 1。如果 |z| < 1，则将 c 设置为 sqrt(1 - z^2) 并将 s 设置为 z。如果 |z| > 1，则将 c 设置为 1/z 并将 s 设置为 sqrt( 1 - c^2)。

DROTM 应用修改后的 Givens 变换。$H$到2×N矩阵 $$\left[ \begin{array}{c}DX^T\\DY^T\\ \end{array} \right],$$ 其中$^T$表示转置。元素$DX$位于DX(LX+IINCX), I = 0:N-1，其中LX = 1如果INCX >= 0，否则LX = (-INCX)N，对于DY使用LY和INCY类似。使用DPARAM(1)=DFLAG，$H$具有以下形式之一 $$H=\underbrace{\begin{bmatrix}DH_{11} & DH_{12}\\DH_{21} & DH_{22}\end{bmatrix}}_{DFLAG=-1}, \underbrace{\begin{bmatrix}1 & DH_{12}\\DH_{21} & 1\end{bmatrix}}_{DFLAG=0}, \underbrace{\begin{bmatrix}DH_{11} & 1\\-1 & DH_{22}\end{bmatrix}}_{DFLAG=1}, \underbrace{\begin{bmatrix}1 & 0\\0 & 1\end{bmatrix}}_{DFLAG=-2}.$$
有关 DPARAM 中数据存储的描述，请参见 DROTMG。

DROTMG 构造修改后的 Givens 变换矩阵$H$它将2向量 $$\left[ {\sqrt{DD_1}\cdot DX_1,\sqrt{DD_2}\cdot DY_2} \right]^T.$$ 的第二部分归零。使用DPARAM(1)=DFLAG，$H$具有以下形式之一
$$H=\underbrace{\begin{bmatrix}DH_{11} & DH_{12}\\DH_{21} & DH_{22}\end{bmatrix}}_{DFLAG=-1}, \underbrace{\begin{bmatrix}1 & DH_{12}\\DH_{21} & 1\end{bmatrix}}_{DFLAG=0}, \underbrace{\begin{bmatrix}DH_{11} & 1\\-1 & DH_{22}\end{bmatrix}}_{DFLAG=1}, \underbrace{\begin{bmatrix}1 & 0\\0 & 1\end{bmatrix}}_{DFLAG=-2}.$$ DPARAM的第2-4个位置分别包含DH11、DH21、DH12和DH22。（DPARAM(1)的值隐含的1.0、-1.0或0.0的值不会存储在DPARAM中。）参数GAMSQ和RGAMSQ的值可能不精确。这没关系，因为它们仅用于测试DD1和DD2的大小。所有实际的数据缩放都是使用GAM完成的。

DSBMV 执行矩阵向量运算 y := alpha * A * x + beta * y，其中 alpha 和 beta 是标量，x 和 y 是 n 元素向量，A 是一个 n 行 n 列的对称带状矩阵，具有 k 个超对角线。

DSCAL 用常数缩放向量。对于等于 1 的增量使用展开的循环。

计算两个向量的内积，并使用扩展精度累积和结果。返回 D.P. 点积，在 D.P. 中累积，用于 S.P. SX 和 SY DSDOT = sum for I = 0 to N-1 of SX(LX+I*INCX) * SY(LY+I*INCY)，其中 LX = 1 if INCX >= 0, else LX = 1+(1-N)*INCX，LY 的定义方式类似，使用 INCY。

DSPMV 执行矩阵向量运算 y := alpha * A * x + beta * y，其中 alpha 和 beta 是标量，x 和 y 是 n 元素向量，A 是一个 n 行 n 列的对称矩阵，以打包形式提供。

DSPR 执行对称秩 1 运算 A := alpha * x * x^T + A，其中 alpha 是一个实数标量，x 是一个 n 元素向量，而 A 是一个 n 行 n 列的对称矩阵，以打包形式提供。

DSPR2 执行对称秩 2 运算 A := alpha * x * y^T + alpha * y * x^T + A，其中 alpha 是一个标量，x 和 y 是 n 元素向量，而 A 是一个 n 行 n 列的对称矩阵，以打包形式提供。

DSWAP 交换两个向量。对于等于 1 的增量使用展开的循环。

DSYMM 执行以下矩阵乘法运算之一：C := alpha*A*B + beta*C 或 C := alpha*B*A + beta*C，其中 alpha 和 beta 是标量，A 是对称矩阵，B 和 C 是 m 行 n 列矩阵。

DSYMV 执行矩阵-向量运算 y := alpha*A*x + beta*y，其中 alpha 和 beta 是标量，x 和 y 是 n 个元素的向量，A 是 n 行 n 列对称矩阵。

DSYR 执行对称秩 1 运算 A := alpha*x*x**T + A，其中 alpha 是实数标量，x 是 n 个元素的向量，A 是 n 行 n 列对称矩阵。

DSYR2 执行对称秩 2 运算 A := alpha*x*y**T + alpha*y*x**T + A，其中 alpha 是标量，x 和 y 是 n 个元素的向量，A 是 n 行 n 列对称矩阵。

DSYR2K 执行以下对称秩 2k 运算之一：C := alpha*A*B**T + alpha*B*A**T + beta*C 或 C := alpha*A**T*B + alpha*B**T*A + beta*C，其中 alpha 和 beta 是标量，C 是 n 行 n 列对称矩阵，A 和 B 在第一种情况下是 n 行 k 列矩阵，在第二种情况下是 k 行 n 列矩阵。

DSYRK 执行以下对称秩 k 运算之一：C := alpha*A*A**T + beta*C 或 C := alpha*A**T*A + beta*C，其中 alpha 和 beta 是标量，C 是 n 行 n 列对称矩阵，A 在第一种情况下是 n 行 k 列矩阵，在第二种情况下是 k 行 n 列矩阵。

DTBMV 执行以下矩阵-向量运算之一：x := A*x 或 x := A**T*x，其中 x 是 n 个元素的向量，A 是 n 行 n 列单位或非单位上三角或下三角带状矩阵，具有 (k + 1) 条对角线。

DTBSV 求解以下方程组之一：A*x = b 或 A**T*x = b，其中 b 和 x 是 n 个元素的向量，A 是 n 行 n 列单位或非单位上三角或下三角带状矩阵，具有 (k + 1) 条对角线。此例程中不包含奇异性或接近奇异性的测试。在调用此例程之前，必须执行此类测试。

DTPMV 执行以下矩阵-向量运算之一：x := A*x 或 x := A**T*x，其中 x 是 n 个元素的向量，A 是 n 行 n 列单位或非单位上三角或下三角矩阵，以打包形式提供。

DTPSV 求解以下方程组之一：A*x = b 或 A**T*x = b，其中 b 和 x 是 n 个元素的向量，A 是 n 行 n 列单位或非单位上三角或下三角矩阵，以打包形式提供。此例程中不包含奇异性或接近奇异性的测试。在调用此例程之前，必须执行此类测试。

DTRMM 执行以下矩阵乘法运算之一：B := alpha*op(A)*B 或 B := alpha*B*op(A)，其中 alpha 是标量，B 是 m 行 n 列矩阵，A 是单位或非单位上三角或下三角矩阵，op(A) 是以下之一：op(A) = A 或 op(A) = A**T。

DTRMV 执行以下矩阵-向量运算之一：x := A*x 或 x := A**T*x，其中 x 是 n 个元素的向量，A 是 n 行 n 列单位或非单位上三角或下三角矩阵。

DTRSM 求解以下矩阵方程之一：op(A)*X = alpha*B 或 X*op(A) = alpha*B，其中 alpha 是标量，X 和 B 是 m 行 n 列矩阵，A 是单位或非单位上三角或下三角矩阵，op(A) 是以下之一：op(A) = A 或 op(A) = A**T。矩阵 X 将覆盖到 B 上。

DTRSV 求解以下方程组之一：A*x = b 或 A**T*x = b，其中 b 和 x 是 n 个元素的向量，A 是 n 行 n 列单位或非单位上三角或下三角矩阵。此例程中不包含奇异性或接近奇异性的测试。在调用此例程之前，必须执行此类测试。

DZASUM 对复向量取 (|Re(.)| + |Im(.)|) 的总和，并返回双精度结果。

DZNRM2 通过函数名返回向量的欧几里德范数，因此 DZNRM2 := sqrt( x**H*x )

LSAME 如果 CA 与 CB 是同一个字母，无论大小写，则返回 .TRUE.。

SASUM 对绝对值求和。对于增量等于 1，使用展开循环。

SAXPY 常数乘以向量加上向量。对于增量等于 1，使用展开循环。

SCASUM 对复向量取 (|Re(.)| + |Im(.)|) 的总和，并返回单精度结果。

SCNRM2 通过函数名返回向量的欧几里德范数，因此 SCNRM2 := sqrt( x**H*x )

SCOPY 将向量 x 复制到向量 y。对于增量等于 1，使用展开循环。

SDOT 生成两个向量的点积。对于增量等于 1，使用展开循环。

计算两个向量的内积，并进行扩展精度累加。返回 S.P. 结果，点积在 D.P. 中累加 SDSDOT = SB + sum for I = 0 to N-1 of SX(LX+I*INCX)*SY(LY+I*INCY)，其中 LX = 1 if INCX >= 0，否则 LX = 1+(1-N)*INCX，LY 以类似方式使用 INCY 定义。

SGBMV 执行以下矩阵-向量运算之一：y := alpha*A*x + beta*y 或 y := alpha*A**T*x + beta*y，其中 alpha 和 beta 是标量，x 和 y 是向量，A 是 m 行 n 列带状矩阵，具有 kl 个次对角线和 ku 个超对角线。

SGEMM 执行以下矩阵乘法运算之一：C := alpha*op(A)*op(B) + beta*C，其中 op(X) 是以下之一：op(X) = X 或 op(X) = X**T，alpha 和 beta 是标量，A、B 和 C 是矩阵，其中 op(A) 是 m 行 k 列矩阵，op(B) 是 k 行 n 列矩阵，C 是 m 行 n 列矩阵。

SGEMV 执行以下矩阵-向量运算之一：y := alpha*A*x + beta*y 或 y := alpha*A**T*x + beta*y，其中 alpha 和 beta 是标量，x 和 y 是向量，A 是 m 行 n 列矩阵。

SGER 执行秩 1 运算 A := alpha*x*y**T + A，其中 alpha 是标量，x 是 m 个元素的向量，y 是 n 个元素的向量，A 是 m 行 n 列矩阵。

SNRM2 通过函数名返回向量的欧几里德范数，因此 SNRM2 := sqrt( x'*x )。

应用平面旋转。

计算使用公式 sigma = sgn(a) if |a| > |b| = sgn(b) if |b| >= |a| r = sigma * sqrt( a^2 + b^2 ) c = 1; s = 0 if r = 0 c = a/r; s = b/r if r != 0 子例程还计算 z = s if |a| > |b|, = 1/c if |b| >= |a| and c != 0 = 1 if c = 0 这允许根据 z 重构 c 和 s：如果 z = 1，则将 c 设置为 0，将 s 设置为 1。如果 |z| < 1，则将 c 设置为 sqrt(1 - z^2) 并将 s 设置为 z。如果 |z| > 1，则将 c 设置为 1/z 并将 s 设置为 sqrt( 1 - c^2)。

SROTM 应用修改后的 Givens 变换，$H$到2×N矩阵 $$\left[ \begin{array}{c}SX^T\\SY^T\\ \end{array} \right],$$ 其中$^T$表示转置。元素$SX$位于 SX(LX+I*INCX) 中，I = 0:N-1，其中 LX = 1 if INCX >= 0，否则 LX = (-INCX)*N，对于 SY 使用 LY 和 INCY 类似。SPARAM(1)=SFLAG 时，$H$具有以下形式之一 $$H=\underbrace{\begin{bmatrix}SH_{11} & SH_{12}\\SH_{21} & SH_{22}\end{bmatrix}}_{SFLAG=-1}, \underbrace{\begin{bmatrix}1 & SH_{12}\\SH_{21} & 1\end{bmatrix}}_{SFLAG=0}, \underbrace{\begin{bmatrix}SH_{11} & 1\\-1 & SH_{22}\end{bmatrix}}_{SFLAG=1}, \underbrace{\begin{bmatrix}1 & 0\\0 & 1\end{bmatrix}}_{SFLAG=-2}.$$
有关 SPARAM 中数据存储的说明，请参见 SROTMG。

SROTMG 构造修改后的 Givens 变换矩阵$H$它将2向量 $$\left[ {\sqrt{SD_1}\cdot SX_1,\sqrt{SD_2}\cdot SY_2} \right]^T.$$ SPARAM(1)=SFLAG 时，$H$具有以下形式之一
$$H=\underbrace{\begin{bmatrix}SH_{11} & SD_{12}\\SH_{21} & SH_{22}\end{bmatrix}}_{SFLAG=-1}, \underbrace{\begin{bmatrix}1 & SH_{12}\\SH_{21} & 1\end{bmatrix}}_{SFLAG=0}, \underbrace{\begin{bmatrix}SH_{11} & 1\\-1 & SH_{22}\end{bmatrix}}_{SFLAG=1}, \underbrace{\begin{bmatrix}1 & 0\\0 & 1\end{bmatrix}}_{SFLAG=2}.$$ SPARAM 的位置 2-4 分别包含 SH11、SH21、SH12 和 SH22。（SPARAM(1) 的值隐含的 1.0、-1.0 或 0.0 值不会存储在 SPARAM 中。）参数 GAMSQ 和 RGAMSQ 的值可能不精确。这没关系，因为它们仅用于测试 DD1 和 DD2 的大小。所有实际数据的缩放都使用 GAM 完成。

SSBMV 执行矩阵-向量运算 y := alpha*A*x + beta*y，其中 alpha 和 beta 是标量，x 和 y 是 n 个元素的向量，A 是 n 行 n 列对称带状矩阵，具有 k 个超对角线。

SSCAL 按常数缩放向量。对于增量等于 1，使用展开循环。

SSPMV 执行矩阵-向量运算 y := alpha*A*x + beta*y，其中 alpha 和 beta 是标量，x 和 y 是 n 个元素的向量，A 是 n 行 n 列对称矩阵，以打包形式提供。

SSPR 执行对称秩 1 运算 A := alpha*x*x**T + A，其中 alpha 是实数标量，x 是 n 个元素的向量，A 是 n 行 n 列对称矩阵，以打包形式提供。

SSPR2 执行对称秩 2 运算 A := alpha*x*y**T + alpha*y*x**T + A，其中 alpha 是标量，x 和 y 是 n 个元素的向量，A 是 n 行 n 列对称矩阵，以打包形式提供。

SSWAP 交换两个向量。对于增量等于 1，使用展开循环。

SSYMM 执行以下矩阵乘法运算之一：C := alpha*A*B + beta*C 或 C := alpha*B*A + beta*C，其中 alpha 和 beta 是标量，A 是对称矩阵，B 和 C 是 m 行 n 列矩阵。

SSYMV 执行矩阵-向量运算 y := alpha*A*x + beta*y，其中 alpha 和 beta 是标量，x 和 y 是 n 个元素的向量，A 是 n 行 n 列对称矩阵。

SSYR 执行对称秩 1 运算 A := alpha*x*x**T + A，其中 alpha 是实数标量，x 是 n 个元素的向量，A 是 n 行 n 列对称矩阵。

SSYR2 执行对称秩 2 运算 A := alpha*x*y**T + alpha*y*x**T + A，其中 alpha 是标量，x 和 y 是 n 个元素的向量，A 是 n 行 n 列对称矩阵。

SSYR2K 执行以下对称秩 2k 运算之一：C := alpha*A*B**T + alpha*B*A**T + beta*C 或 C := alpha*A**T*B + alpha*B**T*A + beta*C，其中 alpha 和 beta 是标量，C 是 n 行 n 列对称矩阵，A 和 B 在第一种情况下是 n 行 k 列矩阵，在第二种情况下是 k 行 n 列矩阵。

SSYRK 执行以下对称秩 k 运算之一：C := alpha*A*A**T + beta*C 或 C := alpha*A**T*A + beta*C，其中 alpha 和 beta 是标量，C 是 n 行 n 列对称矩阵，A 在第一种情况下是 n 行 k 列矩阵，在第二种情况下是 k 行 n 列矩阵。

STBMV 执行以下矩阵-向量运算之一：x := A*x 或 x := A**T*x，其中 x 是 n 个元素的向量，A 是 n 行 n 列单位或非单位上三角或下三角带状矩阵，具有 (k + 1) 条对角线。

STBSV 求解以下方程组之一：A*x = b 或 A**T*x = b，其中 b 和 x 是 n 个元素的向量，A 是 n 行 n 列单位或非单位上三角或下三角带状矩阵，具有 (k + 1) 条对角线。此例程中不包含奇异性或接近奇异性的测试。在调用此例程之前，必须执行此类测试。

STPMV 执行以下矩阵-向量运算之一：x := A*x 或 x := A**T*x，其中 x 是 n 个元素的向量，A 是 n 行 n 列单位或非单位上三角或下三角矩阵，以打包形式提供。

STPSV 求解以下方程组之一：A*x = b 或 A**T*x = b，其中 b 和 x 是 n 个元素的向量，A 是 n 行 n 列单位或非单位上三角或下三角矩阵，以打包形式提供。此例程中不包含奇异性或接近奇异性的测试。在调用此例程之前，必须执行此类测试。

STRMM 执行以下矩阵乘法运算之一：B := alpha*op(A)*B 或 B := alpha*B*op(A)，其中 alpha 是标量，B 是 m 行 n 列矩阵，A 是单位或非单位上三角或下三角矩阵，op(A) 是以下之一：op(A) = A 或 op(A) = A**T。

STRMV 执行以下矩阵-向量运算之一：x := A*x 或 x := A**T*x，其中 x 是 n 个元素的向量，A 是 n 行 n 列单位或非单位上三角或下三角矩阵。

STRSM 求解矩阵方程之一 op( A )*X = alpha*B 或 X*op( A ) = alpha*B，其中 alpha 为标量，X 和 B 为 m x n 矩阵，A 为单位或非单位，上三角或下三角矩阵，op( A ) 为 op( A ) = A 或 op( A ) = A**T 之一。矩阵 X 会覆盖到 B 上。

STRSV 求解方程组之一 A*x = b 或 A*T*x = b，其中 b 和 x 为 n 元素向量，A 为 n x n 单位或非单位，上三角或下三角矩阵。该例程中不包含奇异性或近似奇异性的测试。在调用该例程之前，必须执行此类测试。

XERBLA 是 LAPACK 例程的错误处理程序。如果输入参数的值无效，LAPACK 例程会调用它。系统会打印一条消息并停止执行。安装程序可以考虑修改 STOP 语句以调用特定于系统的异常处理机制。

XERBLA_ARRAY 帮助其他语言调用 XERBLA（LAPACK 和 BLAS 错误处理程序）。XERBLA_ARRAY 不像函数名那样使用 Fortran 字符串参数，而是使用字符数组以及数组的长度。然后，XERBLA_ARRAY 会将该数组中最多 32 个字符复制到 Fortran 字符串中，并将其传递给 XERBLA。如果调用时 SRNAME_LEN 为非正数，XERBLA_ARRAY 会使用全空格字符串调用 XERBLA。假设某个宏或其他机制通过名为 lapack_xerbla 的名称以通用 Fortran 调用约定向 C99 提供了 XERBLA_ARRAY。那么 C99 程序可以通过以下方式调用 XERBLA：{ int flen = strlen(func); lapack_xerbla(func, } 提供 XERBLA_ARRAY 并非拦截 LAPACK 错误所必需。XERBLA_ARRAY 会调用 XERBLA。

ZAXPY 常数乘以向量加上向量。

ZCOPY 将向量 x 复制到向量 y。

ZDOTC 计算两个复数向量的点积 ZDOTC = X^H * Y

ZDOTU 计算两个复数向量的点积 ZDOTU = X^T * Y

应用平面旋转，其中 cos 和 sin（c 和 s）为实数，向量 cx 和 cy 为复数。jack dongarra, linpack, 3/11/78。

ZDSCAL 将向量按常数缩放。

ZGBMV 执行矩阵-向量运算之一 y := alpha*A*x + beta*y 或 y := alpha*A**T*x + beta*y 或 y := alpha*A**H*x + beta*y，其中 alpha 和 beta 为标量，x 和 y 为向量，A 为 m x n 带状矩阵，具有 kl 个次对角线和 ku 个超对角线。

ZGEMM 执行矩阵-矩阵运算之一 C := alpha*op( A )*op( B ) + beta*C，其中 op( X ) 为 op( X ) = X 或 op( X ) = X*T 或 op( X ) = X*H 之一，alpha 和 beta 为标量，A、B 和 C 为矩阵，其中 op( A ) 为 m x k 矩阵，op( B ) 为 k x n 矩阵，C 为 m x n 矩阵。

ZGEMV 执行矩阵-向量运算之一 y := alpha*A*x + beta*y 或 y := alpha*A**T*x + beta*y 或 y := alpha*A**H*x + beta*y，其中 alpha 和 beta 为标量，x 和 y 为向量，A 为 m x n 矩阵。

ZGERC 执行秩 1 运算 A := alpha*x*y**H + A，其中 alpha 为标量，x 为 m 元素向量，y 为 n 元素向量，A 为 m x n 矩阵。

ZGERU 执行秩 1 运算 A := alpha*x*y**T + A，其中 alpha 为标量，x 为 m 元素向量，y 为 n 元素向量，A 为 m x n 矩阵。

ZHBMV 执行矩阵-向量运算 y := alpha*A*x + beta*y，其中 alpha 和 beta 为标量，x 和 y 为 n 元素向量，A 为 n x n 厄米特带状矩阵，具有 k 个超对角线。

ZHEMM 执行矩阵-矩阵运算之一 C := alpha*A*B + beta*C 或 C := alpha*B*A + beta*C，其中 alpha 和 beta 为标量，A 为厄米特矩阵，B 和 C 为 m x n 矩阵。

ZHEMV 执行矩阵-向量运算 y := alpha*A*x + beta*y，其中 alpha 和 beta 为标量，x 和 y 为 n 元素向量，A 为 n x n 厄米特矩阵。

ZHER 执行厄米特秩 1 运算 A := alpha*x*x**H + A，其中 alpha 为实数标量，x 为 n 元素向量，A 为 n x n 厄米特矩阵。

ZHER2 执行厄米特秩 2 运算 A := alpha*x*y**H + conjg( alpha )*y*x**H + A，其中 alpha 为标量，x 和 y 为 n 元素向量，A 为 n x n 厄米特矩阵。

ZHER2K 执行厄米特秩 2k 运算之一 C := alpha*A*B**H + conjg( alpha )*B*A**H + beta*C 或 C := alpha*A**H*B + conjg( alpha )*B**H*A + beta*C，其中 alpha 和 beta 为标量，其中 beta 为实数，C 为 n x n 厄米特矩阵，A 和 B 为第一种情况下为 n x k 矩阵，第二种情况下为 k x n 矩阵。

ZHERK 执行厄米特秩 k 运算之一 C := alpha*A*A**H + beta*C 或 C := alpha*A**H*A + beta*C，其中 alpha 和 beta 为实数标量，C 为 n x n 厄米特矩阵，A 为第一种情况下为 n x k 矩阵，第二种情况下为 k x n 矩阵。

ZHPMV 执行矩阵-向量运算 y := alpha*A*x + beta*y，其中 alpha 和 beta 为标量，x 和 y 为 n 元素向量，A 为 n x n 厄米特矩阵，以打包形式提供。

ZHPR 执行厄米特秩 1 运算 A := alpha*x*x**H + A，其中 alpha 为实数标量，x 为 n 元素向量，A 为 n x n 厄米特矩阵，以打包形式提供。

ZHPR2 执行厄米特秩 2 运算 A := alpha*x*y**H + conjg( alpha )*y*x**H + A，其中 alpha 为标量，x 和 y 为 n 元素向量，A 为 n x n 厄米特矩阵，以打包形式提供。

计算使用公式 |x| = sqrt( Re(x)**2 + Im(x)**2 ) sgn(x) = x / |x| if x /= 0 = 1 if x = 0 c = |a| / sqrt(|a|**2 + |b|**2) s = sgn(a) * conjg(b) / sqrt(|a|**2 + |b|**2) 当 a 和 b 为实数且 r /= 0 时，公式简化为 r = sgn(a)*sqrt(|a|*2 + |b|*2) c = a / r s = b / r 与 DROTG 中相同，当 |a| > |b| 时。当 |b| >= |a| 时，如果 a 和 b 的符号不同，则 c 和 s 的符号将不同于 DROTG 计算出的符号。

ZSCAL 将向量按常数缩放。

ZSWAP 交换两个向量。

ZSYMM 执行矩阵-矩阵运算之一 C := alpha*A*B + beta*C 或 C := alpha*B*A + beta*C，其中 alpha 和 beta 为标量，A 为对称矩阵，B 和 C 为 m x n 矩阵。

ZSYR2K 执行对称秩 2k 运算之一 C := alpha*A*B**T + alpha*B*A**T + beta*C 或 C := alpha*A**T*B + alpha*B**T*A + beta*C，其中 alpha 和 beta 为标量，C 为 n x n 对称矩阵，A 和 B 为第一种情况下为 n x k 矩阵，第二种情况下为 k x n 矩阵。

ZSYRK 执行对称秩 k 运算之一 C := alpha*A*A**T + beta*C 或 C := alpha*A**T*A + beta*C，其中 alpha 和 beta 为标量，C 为 n x n 对称矩阵，A 为第一种情况下为 n x k 矩阵，第二种情况下为 k x n 矩阵。

ZTBMV 执行矩阵-向量运算之一 x := A*x 或 x := A*T*x 或 x := A*H*x，其中 x 为 n 元素向量，A 为 n x n 单位或非单位，上三角或下三角带状矩阵，具有 ( k + 1 ) 条对角线。

ZTBSV 求解方程组之一 A*x = b 或 A*T*x = b 或 A*H*x = b，其中 b 和 x 为 n 元素向量，A 为 n x n 单位或非单位，上三角或下三角带状矩阵，具有 ( k + 1 ) 条对角线。该例程中不包含奇异性或近似奇异性的测试。在调用该例程之前，必须执行此类测试。

ZTPMV 执行矩阵-向量运算之一 x := A*x 或 x := A*T*x 或 x := A*H*x，其中 x 为 n 元素向量，A 为 n x n 单位或非单位，上三角或下三角矩阵，以打包形式提供。

ZTPSV 求解方程组之一 A*x = b 或 A*T*x = b 或 A*H*x = b，其中 b 和 x 为 n 元素向量，A 为 n x n 单位或非单位，上三角或下三角矩阵，以打包形式提供。该例程中不包含奇异性或近似奇异性的测试。在调用该例程之前，必须执行此类测试。

ZTRMM 执行矩阵-矩阵运算之一 B := alpha*op( A )*B 或 B := alpha*B*op( A )，其中 alpha 为标量，B 为 m x n 矩阵，A 为单位或非单位，上三角或下三角矩阵，op( A ) 为 op( A ) = A 或 op( A ) = A**T 或 op( A ) = A**H 之一。

ZTRMV 执行矩阵-向量运算之一 x := A*x 或 x := A*T*x 或 x := A*H*x，其中 x 为 n 元素向量，A 为 n x n 单位或非单位，上三角或下三角矩阵。

ZTRSM 求解矩阵方程之一 op( A )*X = alpha*B 或 X*op( A ) = alpha*B，其中 alpha 为标量，X 和 B 为 m x n 矩阵，A 为单位或非单位，上三角或下三角矩阵，op( A ) 为 op( A ) = A 或 op( A ) = A**T 或 op( A ) = A**H 之一。矩阵 X 会覆盖到 B 上。

ZTRSV 求解方程组之一 A*x = b 或 A*T*x = b 或 A*H*x = b，其中 b 和 x 为 n 元素向量，A 为 n x n 单位或非单位，上三角或下三角矩阵。该例程中不包含奇异性或近似奇异性的测试。在调用该例程之前，必须执行此类测试。

用于新字符串实例的构造函数

stringlist 的构造函数 返回 stringlist_type 类型的一个实例 规格

删除开头和结尾的空格字符。

计算 real 或 complex 2D 矩阵的奇异值分解。(规范)

计算 real 或 complex 2D 矩阵的奇异值。(规范)

SWAP 交换两个向量。

SYMM 执行以下矩阵-矩阵运算之一：C := alphaAB + betaC 或 C := alphaBA + betaC，其中 alpha 和 beta 是标量，A 是对称矩阵，B 和 C 是 m×n 矩阵。

SYMV 执行以下矩阵-向量运算：y := alphaAx + beta*y，其中 alpha 和 beta 是标量，x 和 y 是 n 元素向量，A 是 n×n 对称矩阵。

SYR 执行以下对称秩 1 运算：A := alphaxx**T + A，其中 alpha 是实数标量，x 是 n 元素向量，A 是 n×n 对称矩阵。

SYR2 执行以下对称秩 2 运算：A := alphaxy**T + alphayx**T + A，其中 alpha 是标量，x 和 y 是 n 元素向量，A 是 n×n 对称矩阵。

SYR2K 执行以下对称秩 2k 运算之一：C := alphaAB**T + alphaBA**T + betaC 或 C := alphaA**TB + alphaB**TA + betaC，其中 alpha 和 beta 是标量，C 是 n×n 对称矩阵，A 和 B 在第一种情况下是 n×k 矩阵，在第二种情况下是 k×n 矩阵。

SYRK 执行以下对称秩 k 运算之一：C := alphaAA**T + betaC 或 C := alphaA**TA + betaC，其中 alpha 和 beta 是标量，C 是 n×n 对称矩阵，A 在第一种情况下是 n×k 矩阵，在第二种情况下是 k×n 矩阵。

TBMV 执行以下矩阵-向量运算之一：x := Ax 或 x := ATx 或 x := A*Hx，其中 x 是 n 元素向量，A 是 n×n 单位或非单位上三角或下三角带矩阵，具有 (k + 1) 个对角线。

TBSV 求解以下方程组之一：Ax = b 或 ATx = b 或 A*Hx = b，其中 b 和 x 是 n 元素向量，A 是 n×n 单位或非单位上三角或下三角带矩阵，具有 (k + 1) 个对角线。此例程不包括奇异性或近似奇异性测试。在调用此例程之前，必须执行此类测试。

返回输入字符串持有的字符序列的小写版本。

将字符变量转换为小写（规范）

将字符串转换为数字（规范）

将字符串中的一系列值转换为数字（规范）

获取常数值或不确定性。

返回输入字符串持有的字符序列的句子式版本。

将字符序列转换为句子式（规范）

将其他类型格式化为字符串或将其转换为字符串。（规范）

返回输入字符串持有的字符序列的标题式版本。

将字符序列转换为标题式（规范）

返回输入字符串持有的字符序列的大写版本。

将字符变量转换为大写（规范）

TPMV 执行以下矩阵-向量运算之一：x := Ax 或 x := ATx 或 x := A*Hx，其中 x 是 n 元素向量，A 是 n×n 单位或非单位上三角或下三角矩阵，以打包形式提供。

TPSV 求解以下方程组之一：Ax = b 或 ATx = b 或 A*Hx = b，其中 b 和 x 是 n 元素向量，A 是 n×n 单位或非单位上三角或下三角矩阵，以打包形式提供。此例程不包括奇异性或近似奇异性测试。在调用此例程之前，必须执行此类测试。

计算矩阵的迹（规范）

使用梯形法则积分采样值（规范）

使用梯形法则权重积分采样值，以获得给定的横坐标（规范）

返回字符串持有的字符序列，不包括尾随空格。

TRMM 执行以下矩阵-矩阵运算之一：B := alphaop( A )B 或 B := alphaBop( A )，其中 alpha 是标量，B 是 m×n 矩阵，A 是单位或非单位上三角或下三角矩阵，op( A ) 是以下运算之一：op( A ) = A 或 op( A ) = A**T 或 op( A ) = A**H。

TRMV 执行以下矩阵-向量运算之一：x := Ax 或 x := ATx 或 x := A*Hx，其中 x 是 n 元素向量，A 是 n×n 单位或非单位上三角或下三角矩阵。

TRSM 求解以下矩阵方程之一：op( A )X = alphaB 或 Xop( A ) = alphaB，其中 alpha 是标量，X 和 B 是 m×n 矩阵，A 是单位或非单位上三角或下三角矩阵，op( A ) 是以下运算之一：op( A ) = A 或 op( A ) = A**T 或 op( A ) = A**H。矩阵 X 将覆盖 B。

TRSV 求解以下方程组之一：Ax = b 或 ATx = b 或 A*Hx = b，其中 b 和 x 是 n 元素向量，A 是 n×n 单位或非单位上三角或下三角矩阵。此例程不包括奇异性或近似奇异性测试。在调用此例程之前，必须执行此类测试。

返回数组中真值元素的位置。规范

使用“随机”奇数 64 位整数 seed 将 64 位整数 key 映射到仅具有 nbits 位的无符号整数值，其中 nbits 小于 64。（规范）

使用“随机”奇数 32 位整数 seed 将 32 位整数 key 映射到仅具有 nbits 位的无符号整数值，其中 nbits 小于 32（规范）

上不完全伽马函数

数组元素的方差（规范）

扫描字符串，检查是否缺少一组字符。验证字符串中的所有字符是否都属于集合中字符的集合。

WATER_HASH 接口（规范）

将字符串持有的字符序列写入连接的格式化单元。

将字符串持有的字符序列写入连接的非格式化单元。

将 set1 中的位设置为 set1 中原始位与 set2 中位的按位异或。集合必须具有相同的位数，否则结果将是未定义的。（规范）

在输入字符串左侧用零填充。规范