天地传奇3
天地传奇3

OpenBlas API整理

关键字

关键字 英文描述 中文描述
s real, single precision 实数单精度
d real, double precision 实数双精度
c complex, single precision 复数单精度
z complex, double precision 复数双精度
ge general matrix 一般矩阵
gb general band matrix 一般带状矩阵
sy symmetric matrix 对称矩阵
sp symmetric matrix (packed storage) 对称矩阵(压缩存储)
sb symmetric band matrix 对称带状矩阵
mv matrix-vector product 矩阵向量乘积
sv solving a system of linear equations with a single unknown vector 求解含有一个未知向量解线性方程组
mm matrix-matrix product 矩阵矩阵乘积
sm solving a system of linear equations with multiple unknown vectors 求解含有多个未知向量的线性方程组
tr triangular matrix 三角矩阵
tp triangular matrix (packed storage) 三角矩阵（压缩存储
tb triangular band matrix. 三角带状矩阵
  • lda，ldb，ldc：矩阵的前导维数 (主维数)
  • incx，incy：x,y的增量或步长, 一般设置为1
  • X* = conjg(X) ：求X的共轭
  • Order : 指定行-主©或列-主(Fortran)数据排序。
  • Uplo : 指定是使用矩阵中的上三角还是下三角。有效值是“U”或“L”。
  • TransA : 指定是使用矩阵A (‘N’或’n’)还是A (‘T’、‘t’)的转置，共轭（‘C’或’c’）。
  • Diag : 指定矩阵是否是单位三角形。可能的值是“U”(单位三角形)或“N”(非单位三角形)。
  • Side: 决定矩阵相乘的顺序，Side=L（AB） Side=R（BA）。
  • Hermitian 埃尔米特矩阵（又称“自共轭矩阵”）是共轭对称的方阵。埃尔米特矩阵中每一个第i 行第j 列的元素都与第j 行第i 列的元素的共轭相等。n阶复方阵A的对称单元互为共轭，即A的共轭转置矩阵等于它本身，则A是埃尔米特矩阵(Hermitian Matrix)。显然埃尔米特矩阵是实对称矩阵的推广
#ifndef OPENBLAS_CONST
# define OPENBLAS_CONST const
#endif

#define CBLAS_INDEX size_t

typedef enum CBLAS_ORDER     {CblasRowMajor=101, CblasColMajor=102} CBLAS_ORDER;
typedef enum CBLAS_TRANSPOSE {CblasNoTrans=111, CblasTrans=112,  
                              CblasConjTrans=113, CblasConjNoTrans=114} CBLAS_TRANSPOSE;
typedef enum CBLAS_UPLO      {CblasUpper=121, CblasLower=122} CBLAS_UPLO;
typedef enum CBLAS_DIAG      {CblasNonUnit=131, CblasUnit=132} CBLAS_DIAG;
typedef enum CBLAS_SIDE      {CblasLeft=141, CblasRight=142} CBLAS_SIDE;

CBLAS_ORDER ：行优先存储或列优先存储 在C语言中数组是用 行主序，fortran中是列主序
CBLAS_TRANSPOSE ：表示对矩阵执行的转置或共轭
CBLAS_UPLO ：指示要使用对称矩阵的哪一部分
CBLAS_DIAG ：表示三角形矩阵是否为对角线单元(对角线元素都等于1)。
CBLAS_SIDE ：表示矩阵乘法的顺序

一.向量间的运算

BLAS 1级例程和函数组及其数据类型
例程或函数组 数据类型 描述
cblas_?asum s, d, sc, dz 矢量大小和(函数)
cblas_?axpy s, d, c, z 标量-向量乘积(例程)
cblas_?copy s, d, c, z 拷贝向量(例程)
cblas_?dot s, d 点积(函数)
cblas_?sdot sd, d 双精度点积（函数）
cblas_?dotc c, z 共轭点积（函数）
cblas_?dotu c, z 非共轭点积（函数)
cblas_?nrm2 s, d, sc, dz 向量的2范数(欧几里得范数)(函数)
cblas_?rot s, d, cs, zd 点平面旋转(例程)
cblas_?rotg s, d, c, z 生成Givens旋转点（例程）
cblas_?rotm s, d 修改Givens旋转平面中的点（例程
cblas_?rotmg s, d 生成修改后的Givens平面旋转点（例程）
cblas_?scal s, d, c, z, cs, zd 向量-标量点积（例程）
cblas_?swap s, d, c, z 向量交换(例程)
cblas_i?amax s, d, c, z 向量最大绝对值元素的索引(函数)
cblas_i?amin s, d, c, z 向量最小绝对值元素的索引(函数)
cblas_?cabs1 s, d 辅助函数，计算复数的绝对值的单精度或双精度

1. cblas_?asum

float  cblas_sasum (OPENBLAS_CONST blasint n,  
                    OPENBLAS_CONST float  *x, 
                    OPENBLAS_CONST blasint incx);

double cblas_dasum (OPENBLAS_CONST blasint n,  
                    OPENBLAS_CONST double *x,   
                    OPENBLAS_CONST blasint incx);

float  cblas_scasum(OPENBLAS_CONST blasint n,  
                    OPENBLAS_CONST void  *x,  
                    OPENBLAS_CONST blasint incx); 

double cblas_dzasum(OPENBLAS_CONST blasint n,  
                    OPENBLAS_CONST void *x,  
                    OPENBLAS_CONST blasint incx);

n:向量中元素个数，x:向量，incx:求和下标的增量

2.cblas_?axpy

void cblas_saxpy(OPENBLAS_CONST blasint n,  
                 OPENBLAS_CONST float alpha,  
                 OPENBLAS_CONST float *x,  
                 OPENBLAS_CONST blasint incx, 
                 float *y, 
                 OPENBLAS_CONST blasint incy);

void cblas_daxpy(OPENBLAS_CONST blasint n,  
                 OPENBLAS_CONST double alpha,  
                 OPENBLAS_CONST double *x, 
                 OPENBLAS_CONST blasint incx,  
                 double *y, 
                 OPENBLAS_CONST blasint incy);

void cblas_caxpy(OPENBLAS_CONST blasint n,  
                 OPENBLAS_CONST void *alpha,  
                 OPENBLAS_CONST void *x,  
                 OPENBLAS_CONST blasint incx,  
                 void *y,  
                 OPENBLAS_CONST blasint incy); 

void cblas_zaxpy(OPENBLAS_CONST blasint n,  
                 OPENBLAS_CONST void *alpha,  
                 OPENBLAS_CONST void *x, 
                 OPENBLAS_CONST blasint incx,  
                 void *y, 
                 OPENBLAS_CONST blasint incy);

n：向量中元素个数，a：公式中的 α，incx,incy：下标增量
需要注意a的数据类型要和x,y的一样。

3.cblas_?copy

void cblas_scopy(OPENBLAS_CONST blasint n,  
                 OPENBLAS_CONST float *x, 
                 OPENBLAS_CONST blasint incx, 
                 float *y, 
                 OPENBLAS_CONST blasint incy);

void cblas_dcopy(OPENBLAS_CONST blasint n,
                 OPENBLAS_CONST double *x, 
                 OPENBLAS_CONST blasint incx, 
                 double *y, 
                 OPENBLAS_CONST blasint incy);

void cblas_ccopy(OPENBLAS_CONST blasint n, 
                 OPENBLAS_CONST void *x, 
                 OPENBLAS_CONST blasint incx, 
                 void *y, 
                 OPENBLAS_CONST blasint incy);

void cblas_zcopy(OPENBLAS_CONST blasint n, 
                 OPENBLAS_CONST void *x, 
                 OPENBLAS_CONST blasint incx, 
                 void *y, 
                 OPENBLAS_CONST blasint incy);

n：向量中元素个数，incx,incy：下标增量

4.cblas_?dot

#计算两个向量的点积(单精度)。
float  cblas_sdot(OPENBLAS_CONST blasint n, 
                  OPENBLAS_CONST float  *x, 
                  OPENBLAS_CONST blasint incx, 
                  OPENBLAS_CONST float  *y, 
                  OPENBLAS_CONST blasint incy);
#计算两个向量的点积(双精度)。
double cblas_ddot(OPENBLAS_CONST blasint n, 
                  OPENBLAS_CONST double *x, 
                  OPENBLAS_CONST blasint incx, 
                  OPENBLAS_CONST double *y, 
                  OPENBLAS_CONST blasint incy);

n：向量中元素个数， incx,incy：下标增量

5.cblas_?sdot

#计算两个单精度向量与一个初始单精度值的点积。
float  cblas_sdsdot(OPENBLAS_CONST blasint n, 
                    OPENBLAS_CONST float alpha, 
                    OPENBLAS_CONST float *x, 
                    OPENBLAS_CONST blasint incx, 
                    OPENBLAS_CONST float *y, 
                    OPENBLAS_CONST blasint incy);
#计算一对单精度向量的双精度点积。
double cblas_dsdot (OPENBLAS_CONST blasint n,
                    OPENBLAS_CONST float *x, 
                    OPENBLAS_CONST blasint incx, 
                    OPENBLAS_CONST float *y, 
                    OPENBLAS_CONST blasint incy);

n：向量中元素个数, incx,incy：下标增量 , alpha：要添加到点积中的初始值。
sb:仅适用于函数cblas_sdsdot()

6. cblas_?dotc_sub

#计算一个单精度复向量与另一个单精度复向量的复共轭的点积。
void  cblas_cdotc_sub(OPENBLAS_CONST blasint n, 
                      OPENBLAS_CONST void  *x, 
                      OPENBLAS_CONST blasint incx, 
                      OPENBLAS_CONST void  *y, 
                      OPENBLAS_CONST blasint incy, 
                      void  *ret);
#计算双精度复向量的复共轭与第二个双精度复向量的点积。
void  cblas_zdotc_sub(OPENBLAS_CONST blasint n, 
                      OPENBLAS_CONST void *x, 
                      OPENBLAS_CONST blasint incx, 
                      OPENBLAS_CONST void *y, 
                      OPENBLAS_CONST blasint incy, 
                      void *ret);

n: 向量X和Y的长度。ret: 结果向量dotc

6. cblas_?dotc

openblas_complex_float  cblas_cdotc(OPENBLAS_CONST blasint n, 
                                    OPENBLAS_CONST void  *x, 
                                    OPENBLAS_CONST blasint incx, 
                                    OPENBLAS_CONST void  *y, 
                                    OPENBLAS_CONST blasint incy);

openblas_complex_double cblas_zdotc(OPENBLAS_CONST blasint n, 
                                    OPENBLAS_CONST void *x, 
                                    OPENBLAS_CONST blasint incx, 
                                    OPENBLAS_CONST void *y, 
                                    OPENBLAS_CONST blasint incy);

7. cblas_?dotu_sub

#计算两个单精度复向量的点积。
void  cblas_cdotu_sub(OPENBLAS_CONST blasint n, 
                      OPENBLAS_CONST void  *x, 
                      OPENBLAS_CONST blasint incx, 
                      OPENBLAS_CONST void  *y, 
                      OPENBLAS_CONST blasint incy, 
                      void  *ret);
#计算两个双精度复向量的点积。
void  cblas_zdotu_sub(OPENBLAS_CONST blasint n, 
                      OPENBLAS_CONST void *x, 
                      OPENBLAS_CONST blasint incx, 
                      OPENBLAS_CONST void *y, 
                      OPENBLAS_CONST blasint incy, 
                      void *ret);

n: 向量X和Y的长度。ret: 结果向量dotu

7.1. cblas_?dotu

openblas_complex_float  cblas_cdotu(OPENBLAS_CONST blasint n, 
                                    OPENBLAS_CONST void  *x, 
                                    OPENBLAS_CONST blasint incx, 
                                    OPENBLAS_CONST void  *y, 
                                    OPENBLAS_CONST blasint incy);

openblas_complex_double cblas_zdotu(OPENBLAS_CONST blasint n, 
                                    OPENBLAS_CONST void *x, 
                                    OPENBLAS_CONST blasint incx, 
                                    OPENBLAS_CONST void *y, 
                                    OPENBLAS_CONST blasint incy);

8.cblas_?nrm2

#计算向量的L2范数(欧氏长度)(单精度)。
float  cblas_snrm2 (OPENBLAS_CONST blasint N, 
                    OPENBLAS_CONST float  *X, 
                    OPENBLAS_CONST blasint incX);
#计算向量的L2范数(欧氏长度)(双精度)。
double cblas_dnrm2 (OPENBLAS_CONST blasint N, 
                    OPENBLAS_CONST double *X, 
                    OPENBLAS_CONST blasint incX);
#计算向量的酉范数(单精度复数)。
float  cblas_scnrm2(OPENBLAS_CONST blasint N, 
                    OPENBLAS_CONST void  *X, 
                    OPENBLAS_CONST blasint incX);
#计算向量的酉范数(双精度复数)。
double cblas_dznrm2(OPENBLAS_CONST blasint N, 
                    OPENBLAS_CONST void *X, 
                    OPENBLAS_CONST blasint incX);

N : 向量X长度

9.cblas_?rot

将吉文斯旋转矩阵应用于一对向量。

void cblas_srot(OPENBLAS_CONST blasint N, 
                float *X, 
                OPENBLAS_CONST blasint incX, 
                float *Y, 
                OPENBLAS_CONST blasint incY, 
                OPENBLAS_CONST float c,
                OPENBLAS_CONST float s);

void cblas_drot(OPENBLAS_CONST blasint N, 
                double *X, 
                OPENBLAS_CONST blasint incX, 
                double *Y, 
                OPENBLAS_CONST blasint incY, 
                OPENBLAS_CONST double c, 
                OPENBLAS_CONST double  s);

# MKL
void cblas_csrot (const MKL_INT n, 
                  void *x, 
                  const MKL_INT incx, 
                  void *y, 
                  const MKL_INT incy, 
                  const float c, 
                  const float s);

void cblas_zdrot (const MKL_INT n, 
                  void *x, 
                  const MKL_INT incx, 
                  void *y, 
                  const MKL_INT incy, 
                  const double c, 
                  const double s);

N : 向量X和Y中的元素个数。 X : 向量x，返回时修改。Y : 向量y，返回时修改。
c : cos(θ)吉文斯旋转矩阵。s : sin(θ)吉文斯旋转矩阵。

10.cblas_?rotg

吉文斯旋转

void cblas_srotg(float *a, float *b, float *c, float *s);

void cblas_drotg(double *a, double *b, double *c, double *s);

#MKL
void cblas_crotg (void *a, const void *b, float *c, void *s);

void cblas_zrotg (void *a, const void *b, double *c, void *s);

a : 单精度值a.返回时覆盖结果r。 b : 单精度值b.返回时覆盖，结果z(0)。
c : 未使用的条目。在返回的值覆盖cos(θ)。s : 未使用的条目。覆盖在返回值罪(θ)。

11.cblas_?rotm

吉文斯变换

void cblas_srotm(OPENBLAS_CONST blasint N, 
                 float *X, 
                 OPENBLAS_CONST blasint incX, 
                 float *Y, 
                 OPENBLAS_CONST blasint incY, 
                 OPENBLAS_CONST float *P);

void cblas_drotm(OPENBLAS_CONST blasint N, 
                 double *X, 
                 OPENBLAS_CONST blasint incX, 
                 double *Y, 
                 OPENBLAS_CONST blasint incY, 
                 OPENBLAS_CONST double *P);

N : 向量中元素的个数。 X : 向量x，返回时修改。Y : 向量y，返回时修改。

P : 5-元素的向量

P[0]   
    标志值，定义矩阵H的形式。  
    -2.0:矩阵H包含单位矩阵。  
    -1.0:矩阵H与矩阵SH相同(由向量中剩余值定义)。  
    0.0: H[1,2]和H[2,1]由矩阵SH得到，其余均为1.0。  
    1.0: H[1,1]和H[2,2]由矩阵SH得到，H[1,2]为1.0。H(2, 1)是-1.0。  
P[1]  包含 SH[1,1]  
P[2]  包含 SH[2,1]  
P[3]  包含 SH[1,2]  
P[4]  包含 SH[2,2]

12.cblas_?rotmg

计算修改的吉文斯旋转参数

void cblas_srotmg(float *d1, float *d2, float *b1, OPENBLAS_CONST float b2, float *P);

void cblas_drotmg(double *d1, double *d2, double *b1, OPENBLAS_CONST double b2, double *P);

d1 : 比例因子D1， d2 : 比例因子D2， b1 : 比例因子B1， b2 : 比例因子B2，

P : 5-元素的向量

P[0]   
    标志值，定义矩阵H的形式。  
    -2.0:矩阵H包含单位矩阵。  
    -1.0:矩阵H与矩阵SH相同(由向量中剩余值定义)。  
    0.0: H[1,2]和H[2,1]由矩阵SH得到，其余均为1.0。  
    1.0: H[1,1]和H[2,2]由矩阵SH得到，H[1,2]为1.0。H(2, 1)是-1.0。  
P[1]  包含 SH[1,1]  
P[2]  包含 SH[2,1]  
P[3]  包含 SH[1,2]  
P[4]  包含 SH[2,2]

13.cblas_?scal

将向量的每个元素乘以一个常数

void cblas_sscal(OPENBLAS_CONST blasint N, 
                 OPENBLAS_CONST float alpha, 
                 float *X, 
                 OPENBLAS_CONST blasint incX);

void cblas_dscal(OPENBLAS_CONST blasint N, 
                 OPENBLAS_CONST double alpha, 
                 double *X, 
                 OPENBLAS_CONST blasint incX);

void cblas_cscal(OPENBLAS_CONST blasint N, 
                 OPENBLAS_CONST void *alpha, 
                 void *X, 
                 OPENBLAS_CONST blasint incX);

void cblas_zscal(OPENBLAS_CONST blasint N, 
                 OPENBLAS_CONST void *alpha, 
                 void *X, 
                 OPENBLAS_CONST blasint incX);

void cblas_csscal(OPENBLAS_CONST blasint N, 
                  OPENBLAS_CONST float alpha, 
                  void *X, 
                  OPENBLAS_CONST blasint incX);

void cblas_zdscal(OPENBLAS_CONST blasint N, 
                  OPENBLAS_CONST double alpha, 
                  void *X, 
                  OPENBLAS_CONST blasint incX);

alpha : 常数比例因子a

14.cblas_?swap

交换两个向量

void cblas_sswap(OPENBLAS_CONST blasint n, 
                 float *x, 
                 OPENBLAS_CONST blasint incx, 
                 float *y, 
                 OPENBLAS_CONST blasint incy);

void cblas_dswap(OPENBLAS_CONST blasint n, 
                 double *x, 
                 OPENBLAS_CONST blasint incx, 
                 double *y, 
                 OPENBLAS_CONST blasint incy);

void cblas_cswap(OPENBLAS_CONST blasint n, 
                 void *x, 
                 OPENBLAS_CONST blasint incx, 
                 void *y, 
                 OPENBLAS_CONST blasint incy);

void cblas_zswap(OPENBLAS_CONST blasint n, 
                 void *x, 
                 OPENBLAS_CONST blasint incx, 
                 void *y, 
                 OPENBLAS_CONST blasint incy);

15.cblas_i?amax

找到向量中绝对值最大的元素的索引

CBLAS_INDEX cblas_isamax(OPENBLAS_CONST blasint n, 
			 OPENBLAS_CONST float  *x, 
			 OPENBLAS_CONST blasint incx);
						 
CBLAS_INDEX cblas_idamax(OPENBLAS_CONST blasint n, 
			 OPENBLAS_CONST double *x, 
			 OPENBLAS_CONST blasint incx);
						 
CBLAS_INDEX cblas_icamax(OPENBLAS_CONST blasint n, 
			 OPENBLAS_CONST void  *x, 
			 OPENBLAS_CONST blasint incx);
CBLAS_INDEX cblas_izamax(OPENBLAS_CONST blasint n, 
			 OPENBLAS_CONST void *x, 
			 OPENBLAS_CONST blasint incx);

16.cblas_i?amin

元素的绝对值最小的索引（MKL）

CBLAS_INDEX cblas_isamin (const MKL_INT n, const float *x, const MKL_INT incx);
CBLAS_INDEX cblas_idamin (const MKL_INT n, const double *x, const MKL_INT incx);
CBLAS_INDEX cblas_icamin (const MKL_INT n, const void *x, const MKL_INT incx);
CBLAS_INDEX cblas_izamin (const MKL_INT n, const void *x, const MKL_INT incx);

17.cblas_?cabs1 (MKL)

float cblas_scabs1 (const void *z);
double cblas_dcabs1 (const void *z);

二.矩阵与向量

BLAS级别2例程组及其数据类型
例程组 数据类型 描述
cblas_?gbmv s, d, c, z 矩阵-向量乘积使用一个普通的带状矩阵
cblas?_gemv s,d,c,z 矩阵和向量的乘积
cblas_?ger s,d 一般矩阵的Rank-1更新
cblas_?gerc c,z 共轭一般矩阵的Rank-1更新
cblas_?geru c,z 非共轭一般矩阵的Rank-1更新
cblas_?hbmv c,z 矩阵-向量乘积使用埃尔米特带状矩阵
cblas_?hemv c,z 矩阵-向量乘积使用埃尔米特矩阵
cblas_?her c,z 埃尔米特矩阵的Rank-1更新
cblas_?her2 c,z 埃尔米特矩阵的Rank-2更新
cblas_?hpr c,z 埃尔米特压缩矩阵的Rank-1更新
cblas_?hpr2 c,z 埃尔米特压缩矩阵的Rank-2更新
cblas_?sbmv c,z 矩阵-向量乘积使用对称带状矩阵
cblas_?spmv s,d 矩阵-向量乘积使用对称带状压缩矩阵
cblas_?spr s,d 对称压缩矩阵的Rank-1更新
cblas_?spr2 s,d 对称压缩矩阵的Rank-2更新
cblas_?symv s,d 矩阵-向量乘积使用对称矩阵
cblas_?syr s,d 对称矩阵的Rank-1更新
cblas_?syr2 s,d 对称矩阵的Rank-2更新
cblas_?tbmv s, d, c, z 矩阵和向量的乘积使用三角形带状矩阵
cblas_?tbsv s, d, c, z 三角形带状矩阵线性方程组的解
cblas_?tpmv s, d, c, z 矩阵和向量的乘积使用三角形压缩矩阵
cblas_?tpsv s, d, c, z 三角形压缩矩阵线性方程组的解
cblas_?trmv s, d, c, z 矩阵和向量的乘积使用三角形矩阵
cblas_?trsv s, d, c, z 三角形矩阵线性方程组的解

1. cblas_?gbmv

缩放一个普通的带状矩阵，然后乘以一个向量，然后加上一个向量

void cblas_sgbmv(OPENBLAS_CONST enum CBLAS_ORDER order, 
                 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, 
                 OPENBLAS_CONST blasint M, 
                 OPENBLAS_CONST blasint N,
                 OPENBLAS_CONST blasint KL, 
                 OPENBLAS_CONST blasint KU, 
                 OPENBLAS_CONST float alpha, 
                 OPENBLAS_CONST float *A, 
                 OPENBLAS_CONST blasint lda, 
                 OPENBLAS_CONST float *X, 
                 OPENBLAS_CONST blasint incX, 
                 OPENBLAS_CONST float beta, 
                 float *Y, 
                 OPENBLAS_CONST blasint incY);

void cblas_dgbmv(OPENBLAS_CONST enum CBLAS_ORDER order, 
                 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, 
                 OPENBLAS_CONST blasint M, 
                 OPENBLAS_CONST blasint N,
                 OPENBLAS_CONST blasint KL, 
                 OPENBLAS_CONST blasint KU, 
                 OPENBLAS_CONST double alpha, 
                 OPENBLAS_CONST double *A, 
                 OPENBLAS_CONST blasint lda, 
                 OPENBLAS_CONST double *X, 
                 OPENBLAS_CONST blasint incX, 
                 OPENBLAS_CONST double beta, 
                 double *Y, 
                 OPENBLAS_CONST blasint incY);

void cblas_cgbmv(OPENBLAS_CONST enum CBLAS_ORDER order, 
                 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, 
                 OPENBLAS_CONST blasint M, 
                 OPENBLAS_CONST blasint N,
                 OPENBLAS_CONST blasint KL, 
                 OPENBLAS_CONST blasint KU, 
                 OPENBLAS_CONST void *alpha, 
                 OPENBLAS_CONST void *A, 
                 OPENBLAS_CONST blasint lda, 
                 OPENBLAS_CONST void *X, 
                 OPENBLAS_CONST blasint incX, 
                 OPENBLAS_CONST void *beta, 
                 void *Y, 
                 OPENBLAS_CONST blasint incY);

void cblas_zgbmv(OPENBLAS_CONST enum CBLAS_ORDER order, 
                 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, 
                 OPENBLAS_CONST blasint M, 
                 OPENBLAS_CONST blasint N,
                 OPENBLAS_CONST blasint KL, 
                 OPENBLAS_CONST blasint KU, 
                 OPENBLAS_CONST void *alpha, 
                 OPENBLAS_CONST void *A, 
                 OPENBLAS_CONST blasint lda, 
                 OPENBLAS_CONST void *X, 
                 OPENBLAS_CONST blasint incX, 
                 OPENBLAS_CONST void *beta, 
                 void *Y, 
                 OPENBLAS_CONST blasint incY);

M : 矩阵A的行数， N ： 矩阵A的列数
KL ： 矩阵A中的子对角线数。 KU : 矩阵A中超对角线的个数。
alpha : 乘以矩阵A的比例因子。 beta : 用比例因子乘以向量Y。(一般取alpha=1.0,beta=0.0)
lda : 包含矩阵a的数组的前导维数(必须至少为KL+KU+1)。
X,Y : 向量X，Y

2. cblas_?gemv

矩阵乘以向量

void cblas_sgemv(OPENBLAS_CONST enum CBLAS_ORDER order,  
                 OPENBLAS_CONST enum CBLAS_TRANSPOSE trans,  
                 OPENBLAS_CONST blasint m, 
                 OPENBLAS_CONST blasint n,
		 OPENBLAS_CONST float alpha, 
                 OPENBLAS_CONST float  *a, 
                 OPENBLAS_CONST blasint lda,  
                 OPENBLAS_CONST float  *x, 
                 OPENBLAS_CONST blasint incx,  
                 OPENBLAS_CONST float beta,  
                 float  *y, 
                 OPENBLAS_CONST blasint incy);

void cblas_dgemv(OPENBLAS_CONST enum CBLAS_ORDER order,  
                 OPENBLAS_CONST enum CBLAS_TRANSPOSE trans,  
                 OPENBLAS_CONST blasint m, 
                 OPENBLAS_CONST blasint n,
		 OPENBLAS_CONST double alpha, 
                 OPENBLAS_CONST double  *a, 
                 OPENBLAS_CONST blasint lda,  
                 OPENBLAS_CONST double  *x, 
                 OPENBLAS_CONST blasint incx,  
                 OPENBLAS_CONST double beta,  
                 double  *y, 
                 OPENBLAS_CONST blasint incy);

void cblas_cgemv(OPENBLAS_CONST enum CBLAS_ORDER order,  
                 OPENBLAS_CONST enum CBLAS_TRANSPOSE trans,  
                 OPENBLAS_CONST blasint m, 
                 OPENBLAS_CONST blasint n,
		 OPENBLAS_CONST void *alpha, 
                 OPENBLAS_CONST void  *a, 
                 OPENBLAS_CONST blasint lda,  
                 OPENBLAS_CONST void  *x, 
                 OPENBLAS_CONST blasint incx,
                 OPENBLAS_CONST void *beta,
                 void  *y, 
                 OPENBLAS_CONST blasint incy);

void cblas_zgemv(OPENBLAS_CONST enum CBLAS_ORDER order,  
                 OPENBLAS_CONST enum CBLAS_TRANSPOSE trans,  
                 OPENBLAS_CONST blasint m, 
                 OPENBLAS_CONST blasint n,
		 OPENBLAS_CONST void *alpha, 
                 OPENBLAS_CONST void  *a,
                 OPENBLAS_CONST blasint lda,  
                 OPENBLAS_CONST void  *x, 
                 OPENBLAS_CONST blasint incx,  
                 OPENBLAS_CONST void *beta,  
                 void  *y, 
                 OPENBLAS_CONST blasint incy);

m : 矩阵a的行数， n ： 矩阵a的列数

alpha : 矩阵a和向量x乘积的比例因子。 beta : 向量Y的比例因子。
lda : 矩阵a的第一个维度的大小;如果你传递一个矩阵a[m][n]，它的值应该是m。
x,y : 向量x，y

3. cblas_?ger

向量X乘以向量Y的变换，然后加上矩阵A

void cblas_sger (OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST blasint M, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST float   alpha, 
				 OPENBLAS_CONST float  *X, 
				 OPENBLAS_CONST blasint incX, 
				 OPENBLAS_CONST float  *Y, 
				 OPENBLAS_CONST blasint incY, 
				 float  *A, 
				 OPENBLAS_CONST blasint lda);
				 
void cblas_dger (OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST blasint M, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST double  alpha, 
				 OPENBLAS_CONST double *X, 
				 OPENBLAS_CONST blasint incX, 
				 OPENBLAS_CONST double *Y, 
				 OPENBLAS_CONST blasint incY, 
				 double *A, 
				 OPENBLAS_CONST blasint lda);

lda : 包含矩阵A的数组的前导维数。 alpha : 向量X的比例因子

4.cblas_?gerc


共轭向量
alpha *x*conjg(y’) + A.
向量X乘以向量Y的共轭变换，然后加上矩阵A

void cblas_cgerc(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST blasint M, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST void  *alpha, 
				 OPENBLAS_CONST void  *X, 
				 OPENBLAS_CONST blasint incX, 
				 OPENBLAS_CONST void  *Y, 
				 OPENBLAS_CONST blasint incY, 
				 void  *A, 
				 OPENBLAS_CONST blasint lda);

void cblas_zgerc(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST blasint M, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST void *alpha, 
				 OPENBLAS_CONST void *X, 
				 OPENBLAS_CONST blasint incX, 
				 OPENBLAS_CONST void *Y, 
				 OPENBLAS_CONST blasint incY, 
				 void *A, 
				 OPENBLAS_CONST blasint lda);

5. cblas_?geru

非共轭向量
用向量X乘以向量Y的变换，然后加上矩阵A

void cblas_cgeru(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST blasint M, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST void  *alpha, 
				 OPENBLAS_CONST void  *X, 
				 OPENBLAS_CONST blasint incX, 
				 OPENBLAS_CONST void  *Y, 
				 OPENBLAS_CONST blasint incY, 
				 void  *A, 
				 OPENBLAS_CONST blasint lda);

void cblas_zgeru(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST blasint M, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST void *alpha, 
				 OPENBLAS_CONST void *X, 
				 OPENBLAS_CONST blasint incX, 
				 OPENBLAS_CONST void *Y, 
				 OPENBLAS_CONST blasint incY, 
				 void *A, 
				 OPENBLAS_CONST blasint lda);

6. cblas_?hbmv


A是埃尔米特矩阵
缩放埃尔米特带状矩阵A，然后乘以一个向量X，然后加上一个向量Y

void cblas_chbmv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST blasint K,
				 OPENBLAS_CONST void *alpha, 
				 OPENBLAS_CONST void *A, 
				 OPENBLAS_CONST blasint lda, 
				 OPENBLAS_CONST void *X, 
				 OPENBLAS_CONST blasint incX, 
				 OPENBLAS_CONST void *beta, 
				 void *Y, 
				 OPENBLAS_CONST blasint incY);
				 
void cblas_zhbmv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST blasint K,
		 		 OPENBLAS_CONST void *alpha, 
		 		 OPENBLAS_CONST void *A, 
		 		 OPENBLAS_CONST blasint lda, 
		 		 OPENBLAS_CONST void *X, 
		 		 OPENBLAS_CONST blasint incX, 
		 		 OPENBLAS_CONST void *beta, 
		 		 void *Y, 
		 		 OPENBLAS_CONST blasint incY);

7. cblas_?hpmv


缩放一个压缩的埃尔米特矩阵A，乘以一个向量X，然后加上一个缩放的向量Y。结果存储到Y

void cblas_chpmv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST blasint N,
		 		 OPENBLAS_CONST void *alpha, 
		 		 OPENBLAS_CONST void *Ap, 
		 		 OPENBLAS_CONST void *X, 
		 		 OPENBLAS_CONST blasint incX, 
		 		 OPENBLAS_CONST void *beta, 
		 		 void *Y, 
		 		 OPENBLAS_CONST blasint incY);
		 		 
void cblas_zhpmv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST blasint N,
		 		 OPENBLAS_CONST void *alpha, 
		 		 OPENBLAS_CONST void *Ap, 
		 		 OPENBLAS_CONST void *X, 
		 		 OPENBLAS_CONST blasint incX, 
		 		 OPENBLAS_CONST void *beta, 
		 		 void *Y, 
		 		 OPENBLAS_CONST blasint incY);

8. cblas_?trsv

解一个右边只有一个值的三角形方程组。
解A*x=b或A’*x=b其中x和b是x和b中的元素。

void cblas_strsv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, 
				 OPENBLAS_CONST enum CBLAS_DIAG Diag, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST float *A, 
				 OPENBLAS_CONST blasint lda, 
				 float *X, 
				 OPENBLAS_CONST blasint incX);

void cblas_dtrsv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, 
				 OPENBLAS_CONST enum CBLAS_DIAG Diag, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST double *A, 
				 OPENBLAS_CONST blasint lda, 
				 double *X, 
				 OPENBLAS_CONST blasint incX);

void cblas_ctrsv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, 
				 OPENBLAS_CONST enum CBLAS_DIAG Diag, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST void *A, 
				 OPENBLAS_CONST blasint lda, 
				 void *X, 
				 OPENBLAS_CONST blasint incX);

void cblas_ztrsv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo,
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, 
				 OPENBLAS_CONST enum CBLAS_DIAG Diag, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST void *A, 
			  	 OPENBLAS_CONST blasint lda, 
				 void *X, 
				 OPENBLAS_CONST blasint incX);

Uplo : 指定是使用矩阵中的上三角还是下三角。有效值是“U”或“L”。
Diag : 指定矩阵是否是单位三角形。可能的值是“U”(单位三角形)或“N”(非单位三角形)。
lda : 矩阵B的前导维数

9. cblas_?trmv

一个向量乘X以一个三角形矩阵A

void cblas_strmv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, 
				 OPENBLAS_CONST enum CBLAS_DIAG Diag, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST float *A, 
				 OPENBLAS_CONST blasint lda, 
				 float *X, 
				 OPENBLAS_CONST blasint incX);
				 
void cblas_dtrmv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, 
				 OPENBLAS_CONST enum CBLAS_DIAG Diag,
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST double *A, 
				 OPENBLAS_CONST blasint lda, 
				 double *X, 
				 OPENBLAS_CONST blasint incX);
				 
void cblas_ctrmv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, 
				 OPENBLAS_CONST enum CBLAS_DIAG Diag, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST void *A, 
				 OPENBLAS_CONST blasint lda, 
				 void *X, 
				 OPENBLAS_CONST blasint incX);
				 
void cblas_ztrmv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, 
				 OPENBLAS_CONST enum CBLAS_DIAG Diag, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST void *A, 
				 OPENBLAS_CONST blasint lda, 
				 void *X, 
				 OPENBLAS_CONST blasint incX);

Uplo : 指定是使用矩阵中的上三角还是下三角。有效值是“U”或“L”。
Diag : 指定矩阵是否是单位三角形。可能的值是“U”(单位三角形)或“N”(非单位三角形)。
lda : 三角矩阵A的前导维数

10. cblas_?syr

void cblas_ssyr(OPENBLAS_CONST enum CBLAS_ORDER order, 
				OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				OPENBLAS_CONST blasint N, 
				OPENBLAS_CONST float alpha, 
				OPENBLAS_CONST float *X, 
				OPENBLAS_CONST blasint incX, 
				float *A, 
				OPENBLAS_CONST blasint lda);
				
void cblas_dsyr(OPENBLAS_CONST enum CBLAS_ORDER order, 
				OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				OPENBLAS_CONST blasint N, 
				OPENBLAS_CONST double alpha, 
				OPENBLAS_CONST double *X, 
				OPENBLAS_CONST blasint incX, 
				double *A, 
				OPENBLAS_CONST blasint lda);

N : 对称矩阵A的阶数;向量x中的元素个数。
lda : 对称矩阵A的前导维数

11. cblas_?her

void cblas_cher(OPENBLAS_CONST enum CBLAS_ORDER order, 
				OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				OPENBLAS_CONST blasint N, 
				OPENBLAS_CONST float alpha, 
				OPENBLAS_CONST void *X, 
				OPENBLAS_CONST blasint incX, 
				void *A, 
				OPENBLAS_CONST blasint lda);
				
void cblas_zher(OPENBLAS_CONST enum CBLAS_ORDER order, 
				OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				OPENBLAS_CONST blasint N, 
				OPENBLAS_CONST double alpha, 
				OPENBLAS_CONST void *X, 
				OPENBLAS_CONST blasint incX, 
				void *A, 
				OPENBLAS_CONST blasint lda);

N ：矩阵A的阶数。

12. cblas_?syr2

使用两个向量对对称矩阵进行二次更新

void cblas_ssyr2(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo,
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST float alpha, 
				 OPENBLAS_CONST float *X,
                 OPENBLAS_CONST blasint incX, 
                 OPENBLAS_CONST float *Y, 
                 OPENBLAS_CONST blasint incY, 
                 float *A, 
                 OPENBLAS_CONST blasint lda);
                
void cblas_dsyr2(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST double alpha, 
				 OPENBLAS_CONST double *X,
                 OPENBLAS_CONST blasint incX, 
                 OPENBLAS_CONST double *Y, 
                 OPENBLAS_CONST blasint incY, 
                 double *A, 
                 OPENBLAS_CONST blasint lda);

13. cblas_?her2

void cblas_cher2(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST void *alpha, 
				 OPENBLAS_CONST void *X, 
				 OPENBLAS_CONST blasint incX,
                OPENBLAS_CONST void *Y, 
                OPENBLAS_CONST blasint incY, 
                void *A, 
                OPENBLAS_CONST blasint lda);
                
void cblas_zher2(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST void *alpha, 
				 OPENBLAS_CONST void *X, 
				 OPENBLAS_CONST blasint incX,
                 OPENBLAS_CONST void *Y, 
                 OPENBLAS_CONST blasint incY, 
                 void *A, 
                 OPENBLAS_CONST blasint lda);

14. cblas_?sbmv

缩放对称带状矩阵A，然后乘以一个向量X，然后加上一个向量Y，结果存储到Y

void cblas_ssbmv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST blasint K, 
				 OPENBLAS_CONST float alpha, 
				 OPENBLAS_CONST float *A,
                 OPENBLAS_CONST blasint lda, 
                 OPENBLAS_CONST float *X, 
                 OPENBLAS_CONST blasint incX, 
                 OPENBLAS_CONST float beta, 
                 float *Y, 
                 OPENBLAS_CONST blasint incY);
                 
void cblas_dsbmv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST blasint K, 
				 OPENBLAS_CONST double alpha, 
				 OPENBLAS_CONST double *A,
                 OPENBLAS_CONST blasint lda, 
                 OPENBLAS_CONST double *X, 
                 OPENBLAS_CONST blasint incX, 
                 OPENBLAS_CONST double beta, 
                 double *Y, 
                 OPENBLAS_CONST blasint incY);

K : 矩阵A的半带宽。
Y : 向量Y替换为返回的结果。

15. cblas_?tbmv

缩放一个三角形带状矩阵，然后乘以一个向量(单精度)。

void cblas_stbmv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, 
				 OPENBLAS_CONST enum CBLAS_DIAG Diag,
                 OPENBLAS_CONST blasint N, 
                 OPENBLAS_CONST blasint K, 
                 OPENBLAS_CONST float *A, 
                 OPENBLAS_CONST blasint lda, 
                 float *X, 
                 OPENBLAS_CONST blasint incX);
                 
void cblas_dtbmv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, 
				 OPENBLAS_CONST enum CBLAS_DIAG Diag,
                 OPENBLAS_CONST blasint N, 
                 OPENBLAS_CONST blasint K, 
                 OPENBLAS_CONST double *A, 
                 OPENBLAS_CONST blasint lda, 
                 double *X, 
                 OPENBLAS_CONST blasint incX);
                 
void cblas_ctbmv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, 
				 OPENBLAS_CONST enum CBLAS_DIAG Diag,
                 OPENBLAS_CONST blasint N, 
                 OPENBLAS_CONST blasint K, 
                 OPENBLAS_CONST void *A, 
                 OPENBLAS_CONST blasint lda, 
                 void *X, 
                 OPENBLAS_CONST blasint incX);
                 
void cblas_ztbmv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, 
				 OPENBLAS_CONST enum CBLAS_DIAG Diag,
                 OPENBLAS_CONST blasint N, 
                 OPENBLAS_CONST blasint K, 
                 OPENBLAS_CONST void *A, 
                 OPENBLAS_CONST blasint lda, 
                 void *X, 
                 OPENBLAS_CONST blasint incX);

N：矩阵A的阶数。K： 矩阵A的半带宽。 A ： 三角矩阵A

16. cblas_?tbsv


解三角形带状方程组。

void cblas_stbsv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, 
				 OPENBLAS_CONST enum CBLAS_DIAG Diag,
                 OPENBLAS_CONST blasint N, 
                 OPENBLAS_CONST blasint K, 
                 OPENBLAS_CONST float *A, 
                 OPENBLAS_CONST blasint lda, 
                 float *X, 
                 OPENBLAS_CONST blasint incX);
                 
void cblas_dtbsv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, 
				 OPENBLAS_CONST enum CBLAS_DIAG Diag,
                 OPENBLAS_CONST blasint N, 
                 OPENBLAS_CONST blasint K, 
                 OPENBLAS_CONST double *A, 
                 OPENBLAS_CONST blasint lda, 
                 double *X, 
                 OPENBLAS_CONST blasint incX);
                 
void cblas_ctbsv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, 
				 OPENBLAS_CONST enum CBLAS_DIAG Diag,
                 OPENBLAS_CONST blasint N, 
                 OPENBLAS_CONST blasint K, 
                 OPENBLAS_CONST void *A, 
                 OPENBLAS_CONST blasint lda, 
                 void *X, 
                 OPENBLAS_CONST blasint incX);
                 
void cblas_ztbsv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, 
				 OPENBLAS_CONST enum CBLAS_DIAG Diag,
                 OPENBLAS_CONST blasint N, 
                 OPENBLAS_CONST blasint K, 
                 OPENBLAS_CONST void *A, 
                 OPENBLAS_CONST blasint lda, 
                 void *X, 
                 OPENBLAS_CONST blasint incX);

N : 矩阵A的阶数。K : 矩阵A的上对角线或次对角线的数量(取决于Uplo的值)。
X : 包含向量B。返回时用向量X覆盖。

17. cblas_?tpmv


用一个三角形矩阵乘以一个向量

void cblas_stpmv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, 
				 OPENBLAS_CONST enum CBLAS_DIAG Diag,
                 OPENBLAS_CONST blasint N, 
                 OPENBLAS_CONST float *Ap, 
                 float *X, 
                 OPENBLAS_CONST blasint incX);
                 
void cblas_dtpmv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, 
				 OPENBLAS_CONST enum CBLAS_DIAG Diag,
                 OPENBLAS_CONST blasint N, 
                 OPENBLAS_CONST double *Ap, 
                 double *X, 
                 OPENBLAS_CONST blasint incX);
                 
void cblas_ctpmv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
				 OPENBLAS_CONST enum CBLAS_DIAG Diag,
                 OPENBLAS_CONST blasint N, 
                 OPENBLAS_CONST void *Ap, 
                 void *X, 
                 OPENBLAS_CONST blasint incX);
                 
void cblas_ztpmv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, 
				 OPENBLAS_CONST enum CBLAS_DIAG Diag,
                 OPENBLAS_CONST blasint N, 
                 OPENBLAS_CONST void *Ap, 
                 void *X, 
                 OPENBLAS_CONST blasint incX);

N: 矩阵A的阶数以及向量x和y中的元素个数。Ap : 三角矩阵A

18. cblas_?tpsv


求解一个三角形的方程组

void cblas_stpsv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, 
				 OPENBLAS_CONST enum CBLAS_DIAG Diag,
                 OPENBLAS_CONST blasint N, 
                 OPENBLAS_CONST float *Ap, 
                 float *X, 
                 OPENBLAS_CONST blasint incX);
                 
void cblas_dtpsv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, 
				 OPENBLAS_CONST enum CBLAS_DIAG Diag,
                 OPENBLAS_CONST blasint N, 
                 OPENBLAS_CONST double *Ap, 
                 double *X, 
                 OPENBLAS_CONST blasint incX);
                 
void cblas_ctpsv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, 
				 OPENBLAS_CONST enum CBLAS_DIAG Diag,
                 OPENBLAS_CONST blasint N, 
                 OPENBLAS_CONST void *Ap, 
                 void *X, 
                 OPENBLAS_CONST blasint incX);
                 
void cblas_ztpsv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, 
				 OPENBLAS_CONST enum CBLAS_DIAG Diag,
                 OPENBLAS_CONST blasint N, 
                 OPENBLAS_CONST void *Ap, 
                 void *X, 
                 OPENBLAS_CONST blasint incX);

N : 矩阵A的阶数。Ap : 三角形矩阵A(压缩存储格式)。X : 包含向量B。返回时用向量X覆盖。

19. cblas_?symv


缩放对称矩阵A，乘以一个向量X，然后缩放并添加另一个向量Y

void cblas_ssymv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST float alpha, 
				 OPENBLAS_CONST float *A,
                 OPENBLAS_CONST blasint lda, 
                 OPENBLAS_CONST float *X, 
                 OPENBLAS_CONST blasint incX, 
                 OPENBLAS_CONST float beta, 
                 float *Y, 
                 OPENBLAS_CONST blasint incY);
                 
void cblas_dsymv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST double alpha, 
				 OPENBLAS_CONST double *A,
                 OPENBLAS_CONST blasint lda, 
                 OPENBLAS_CONST double *X, 
                 OPENBLAS_CONST blasint incX, 
                 OPENBLAS_CONST double beta, 
                 double *Y, 
                 OPENBLAS_CONST blasint incY);

N : 矩阵A的阶数;向量的长度。 Y : 向量y。包含返回的结果。

20. cblas_?hemv


A为Hermitian 矩阵

void cblas_chemv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST void *alpha, 
				 OPENBLAS_CONST void *A,
                 OPENBLAS_CONST blasint lda, 
                 OPENBLAS_CONST void *X, 
                 OPENBLAS_CONST blasint incX, 
                 OPENBLAS_CONST void *beta, 
                 void *Y, 
                 OPENBLAS_CONST blasint incY);
                 
void cblas_zhemv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST void *alpha, 
				 OPENBLAS_CONST void *A,
                 OPENBLAS_CONST blasint lda, 
                 OPENBLAS_CONST void *X, 
                 OPENBLAS_CONST blasint incX, 
                 OPENBLAS_CONST void *beta, 
                 void *Y, 
                 OPENBLAS_CONST blasint incY);

21. cblas_?spmv


缩放一个压缩矩阵，然后乘以一个向量，然后缩放并添加另一个向量

void cblas_sspmv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST float alpha, 
				 OPENBLAS_CONST float *Ap,
                 OPENBLAS_CONST float *X, 
                 OPENBLAS_CONST blasint incX, 
                 OPENBLAS_CONST float beta, 
                 float *Y, 
                 OPENBLAS_CONST blasint incY);
                 
void cblas_dspmv(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST double alpha, 
				 OPENBLAS_CONST double *Ap,
                 OPENBLAS_CONST double *X, 
                 OPENBLAS_CONST blasint incX, 
                 OPENBLAS_CONST double beta, 
                 double *Y,
                  OPENBLAS_CONST blasint incY);

N： 矩阵A的阶数以及向量x和y中的元素个数。AP： 矩阵A(压缩存储格式)。

22. cblas_?spr


rank one更新：将压缩对称矩阵添加到缩放因子，向量及其转置的乘积。

void cblas_sspr(OPENBLAS_CONST enum CBLAS_ORDER order, 
				OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				OPENBLAS_CONST blasint N, 
				OPENBLAS_CONST float alpha, 
				OPENBLAS_CONST float *X, 
				OPENBLAS_CONST blasint incX, 
				float *Ap);
				
void cblas_dspr(OPENBLAS_CONST enum CBLAS_ORDER order, 
			 	OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
			 	OPENBLAS_CONST blasint N, 
			 	OPENBLAS_CONST double alpha, 
			 	OPENBLAS_CONST double *X, 
			 	OPENBLAS_CONST blasint incX, 
			 	double *Ap);

Ap： 矩阵A(压缩存储格式)。

23. cblas_?hpr


缩放并乘以一个向量乘以它的共轭转置，然后加上一个矩阵。

void cblas_chpr(OPENBLAS_CONST enum CBLAS_ORDER order, 
				OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				OPENBLAS_CONST blasint N, 
				OPENBLAS_CONST float alpha,
				OPENBLAS_CONST void *X, 
				OPENBLAS_CONST blasint incX, 
				void *A);
				
void cblas_zhpr(OPENBLAS_CONST enum CBLAS_ORDER order, 
				OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				OPENBLAS_CONST blasint N, 
				OPENBLAS_CONST double alpha, 
				OPENBLAS_CONST void *X,
				OPENBLAS_CONST blasint incX, 
				void *A);

N： 矩阵A的阶数和向量x中的元素数。A ： 矩阵a被返回的结果覆盖。

24. cblas_?spr2

rank two(r2)更新：使用两个向量对压缩对称矩阵进行秩2更新。

void cblas_sspr2(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST float alpha, 
				 OPENBLAS_CONST float *X, 
				 OPENBLAS_CONST blasint incX, 
				 OPENBLAS_CONST float *Y, 
				 OPENBLAS_CONST blasint incY, 
				 float *A);
				 
void cblas_dspr2(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST double alpha, 
				 OPENBLAS_CONST double *X, 
				 OPENBLAS_CONST blasint incX, 
				 OPENBLAS_CONST double *Y, 
				 OPENBLAS_CONST blasint incY, 
				 double *A);

A： 矩阵A(压缩存储格式)。N : 矩阵A的阶数;向量x中的元素个数。

25. cblas_?hpr2


用一个向量乘以另一个向量的共轭转置，反之亦然，对结果求和，然后加上一个矩阵。

void cblas_chpr2(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST void *alpha, 
				 OPENBLAS_CONST void *X, 
				 OPENBLAS_CONST blasint incX, 
				 OPENBLAS_CONST void *Y, 
				 OPENBLAS_CONST blasint incY, 
				 void *Ap);
				 
void cblas_zhpr2(OPENBLAS_CONST enum CBLAS_ORDER order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST void *alpha, 
				 OPENBLAS_CONST void *X, 
				 OPENBLAS_CONST blasint incX, 
				 OPENBLAS_CONST void *Y, 
				 OPENBLAS_CONST blasint incY, 
				 void *Ap);

Ap : 矩阵A的压缩存储格式。被返回的结果覆盖。N : 矩阵A的阶数以及向量x和y中的元素个数。

三. 矩阵与矩阵

BLAS级别3例程组及其数据类型
例程或函数组 数据类型 描述
cblas_?gemm s, d, c, z 用一般矩阵计算矩阵与矩阵的乘积。
cblas_?hemm c, z 计算矩阵与矩阵的乘积，其中一个输入矩阵是埃尔米特矩阵。
cblas_?herk c, z 埃尔米特矩阵的Rank-k更新
cblas_?her2k c, z 埃尔米特矩阵的Rank-2k更新
cblas_?symm s, d, c, z 计算一个矩阵-矩阵乘积，其中一个输入矩阵是对称的。
cblas_?syrk s, d, c, z 对称矩阵的Rank-k更新
cblas_?syr2k s, d, c, z 对称矩阵的Rank-2k更新
cblas_?trmm s, d, c, z 计算矩阵与矩阵的乘积，其中一个输入矩阵是三角形的。
cblas_?trsm s, d, c, z 解三角形矩阵方程。

1. cblas_?gemm

两个矩阵相乘

void cblas_sgemm(OPENBLAS_CONST enum CBLAS_ORDER Order, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, 
				 OPENBLAS_CONST blasint M, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST blasint K,
				 OPENBLAS_CONST float alpha, 
				 OPENBLAS_CONST float *A, 
				 OPENBLAS_CONST blasint lda, 
				 OPENBLAS_CONST float *B, 
				 OPENBLAS_CONST blasint ldb, 
				 OPENBLAS_CONST float beta, 
				 float *C, 
				 OPENBLAS_CONST blasint ldc);
				 
void cblas_dgemm(OPENBLAS_CONST enum CBLAS_ORDER Order, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, 
				 OPENBLAS_CONST blasint M, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST blasint K,
				 OPENBLAS_CONST double alpha, 
				 OPENBLAS_CONST double *A, 
				 OPENBLAS_CONST blasint lda, 
				 OPENBLAS_CONST double *B, 
				 OPENBLAS_CONST blasint ldb, 
				 OPENBLAS_CONST double beta, 
				 double *C, 
				 OPENBLAS_CONST blasint ldc);
				 
void cblas_cgemm(OPENBLAS_CONST enum CBLAS_ORDER Order, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, 
				 OPENBLAS_CONST blasint M, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST blasint K,
				 OPENBLAS_CONST void *alpha, 
				 OPENBLAS_CONST void *A, 
				 OPENBLAS_CONST blasint lda, 
				 OPENBLAS_CONST void *B, 
				 OPENBLAS_CONST blasint ldb, 
				 OPENBLAS_CONST void *beta, 
				 void *C, 
				 OPENBLAS_CONST blasint ldc);

void cblas_zgemm(OPENBLAS_CONST enum CBLAS_ORDER Order, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, 
				 OPENBLAS_CONST blasint M, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST blasint K,
				 OPENBLAS_CONST void *alpha, 
				 OPENBLAS_CONST void *A, 
				 OPENBLAS_CONST blasint lda, 
				 OPENBLAS_CONST void *B, 
				 OPENBLAS_CONST blasint ldb, 
				 OPENBLAS_CONST void *beta, 
				 void *C, 
				 OPENBLAS_CONST blasint ldc);

M ： 矩阵A和C中的行数。 N： 矩阵B和C的列数。 K : 矩阵A的列数;矩阵B中的行数。
alpha : 矩阵A和B乘积的比例因子。beta : 矩阵C的比例因子。
lda : 矩阵A的第一个维度的大小;如果你传递一个矩阵A[m][n]，它的值应该是m。
ldb : 矩阵B的第一个维度的大小;如果你传递一个矩阵B[m][n]，它的值应该是m。
ldc : 矩阵C的第一个维度的大小;如果你传递一个矩阵C[m][n]，它的值应该是m。

2. cblas_?gemm3m


矩阵相乘（与cblas_?gemm类似，但使用更少的矩阵乘法运算）

void cblas_cgemm3m(OPENBLAS_CONST enum CBLAS_ORDER Order, 
				   OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
				   OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, 
				   OPENBLAS_CONST blasint M, 
				   OPENBLAS_CONST blasint N, 
				   OPENBLAS_CONST blasint K,
				   OPENBLAS_CONST void *alpha, 
				   OPENBLAS_CONST void *A, 
				   OPENBLAS_CONST blasint lda, 
				   OPENBLAS_CONST void *B, 
				   OPENBLAS_CONST blasint ldb, 
				   OPENBLAS_CONST void *beta, 
				   void *C, 
				   OPENBLAS_CONST blasint ldc);

void cblas_zgemm3m(OPENBLAS_CONST enum CBLAS_ORDER Order, 
				   OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, 
				   OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, 
				   OPENBLAS_CONST blasint M, 
				   OPENBLAS_CONST blasint N, 
				   OPENBLAS_CONST blasint K,
				   OPENBLAS_CONST void *alpha, 
				   OPENBLAS_CONST void *A, 
				   OPENBLAS_CONST blasint lda, 
				   OPENBLAS_CONST void *B, 
				   OPENBLAS_CONST blasint ldb, 
				   OPENBLAS_CONST void *beta, 
				   void *C, 
				   OPENBLAS_CONST blasint ldc);

3. cblas_?symm


对称矩阵（A）乘以矩阵

void cblas_ssymm(OPENBLAS_CONST enum CBLAS_ORDER Order, 
				 OPENBLAS_CONST enum CBLAS_SIDE Side, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST blasint M, 
				 OPENBLAS_CONST blasint N,
                 OPENBLAS_CONST float alpha, 
                 OPENBLAS_CONST float *A, 
                 OPENBLAS_CONST blasint lda, 
                 OPENBLAS_CONST float *B,
                 OPENBLAS_CONST blasint ldb, 
                 OPENBLAS_CONST float beta, 
                 float *C, 
                 OPENBLAS_CONST blasint ldc);
                 
void cblas_dsymm(OPENBLAS_CONST enum CBLAS_ORDER Order, 
				 OPENBLAS_CONST enum CBLAS_SIDE Side, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST blasint M, 
				 OPENBLAS_CONST blasint N,
                 OPENBLAS_CONST double alpha, 
                 OPENBLAS_CONST double *A, 
                 OPENBLAS_CONST blasint lda, 
                 OPENBLAS_CONST double *B, 
                 OPENBLAS_CONST blasint ldb, 
                 OPENBLAS_CONST double beta, 
                 double *C, 
                 OPENBLAS_CONST blasint ldc);
                 
void cblas_csymm(OPENBLAS_CONST enum CBLAS_ORDER Order, 
				 OPENBLAS_CONST enum CBLAS_SIDE Side, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST blasint M, 
				 OPENBLAS_CONST blasint N,
                 OPENBLAS_CONST void *alpha, 
                 OPENBLAS_CONST void *A, 
                 OPENBLAS_CONST blasint lda, 
                 OPENBLAS_CONST void *B, 
                 OPENBLAS_CONST blasint ldb, 
                 OPENBLAS_CONST void *beta, 
                 void *C, 
                 OPENBLAS_CONST blasint ldc);
                 
void cblas_zsymm(OPENBLAS_CONST enum CBLAS_ORDER Order, 
				 OPENBLAS_CONST enum CBLAS_SIDE Side, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST blasint M, 
				 OPENBLAS_CONST blasint N,
                 OPENBLAS_CONST void *alpha, 
                 OPENBLAS_CONST void *A, 
                 OPENBLAS_CONST blasint lda, 
                 OPENBLAS_CONST void *B, 
                 OPENBLAS_CONST blasint ldb, 
                 OPENBLAS_CONST void *beta, 
                 void *C, 
                 OPENBLAS_CONST blasint ldc);

M ： 矩阵A和C中的行数。 N： 矩阵B和C的列数。 K : 矩阵A的列数;矩阵B中的行数。
alpha : 矩阵A和B乘积的比例因子。beta : 矩阵C的比例因子。
lda : 矩阵A的第一个维度的大小;如果你传递一个矩阵A[m][n]，它的值应该是m。
ldb : 矩阵B的第一个维度的大小;如果你传递一个矩阵B[m][n]，它的值应该是m。
ldc : 矩阵C的第一个维度的大小;如果你传递一个矩阵C[m][n]，它的值应该是m。

4. cblas_?syrk

Rank-k （rk）更新-将对称矩阵乘以其转置，并添加第二个矩阵

void cblas_ssyrk(OPENBLAS_CONST enum CBLAS_ORDER Order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST blasint K, 
				 OPENBLAS_CONST float alpha, 
				 OPENBLAS_CONST float *A, 
				 OPENBLAS_CONST blasint lda, 
				 OPENBLAS_CONST float beta, 
				 float *C, 
				 OPENBLAS_CONST blasint ldc);
				 
void cblas_dsyrk(OPENBLAS_CONST enum CBLAS_ORDER Order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST blasint K, 
				 OPENBLAS_CONST double alpha, 
				 OPENBLAS_CONST double *A, 
				 OPENBLAS_CONST blasint lda, 
				 OPENBLAS_CONST double beta, 
				 double *C, 
				 OPENBLAS_CONST blasint ldc);
				 
void cblas_csyrk(OPENBLAS_CONST enum CBLAS_ORDER Order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST blasint K, 
				 OPENBLAS_CONST void *alpha, 
				 OPENBLAS_CONST void *A, 
				 OPENBLAS_CONST blasint lda, 
				 OPENBLAS_CONST void *beta, 
				 void *C, 
				 OPENBLAS_CONST blasint ldc);
				 
void cblas_zsyrk(OPENBLAS_CONST enum CBLAS_ORDER Order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST blasint K, 
				 OPENBLAS_CONST void *alpha, 
				 OPENBLAS_CONST void *A, 
				 OPENBLAS_CONST blasint lda, 
				 OPENBLAS_CONST void *beta, 
				 void *C,
				 OPENBLAS_CONST blasint ldc);

N : 矩阵C的阶数。K ：矩阵A中的列数(如果矩阵A被转置，则为行数)。alpha ： 矩阵A的比例因子。
lda : 包含矩阵A的数组的前导维数。 ldc : 包含矩阵C的数组的前导维数。beta : 矩阵C的比例因子。

5. cblas_?syr2k

执行对称矩阵的秩-2k更新

void cblas_ssyr2k(OPENBLAS_CONST enum CBLAS_ORDER Order, 
				  OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				  OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
				  OPENBLAS_CONST blasint N, 
				  OPENBLAS_CONST blasint K, 
				  OPENBLAS_CONST float alpha, 
				  OPENBLAS_CONST float *A, 
				  OPENBLAS_CONST blasint lda,
				  OPENBLAS_CONST float *B, 
				  OPENBLAS_CONST blasint ldb, 
				  OPENBLAS_CONST float beta, 
				  float *C, 
				  OPENBLAS_CONST blasint ldc);
				  
void cblas_dsyr2k(OPENBLAS_CONST enum CBLAS_ORDER Order, 
				  OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				  OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
				  OPENBLAS_CONST blasint N, 
				  OPENBLAS_CONST blasint K, 
				  OPENBLAS_CONST double alpha,
				  OPENBLAS_CONST double *A,
				  OPENBLAS_CONST blasint lda, 
				  OPENBLAS_CONST double *B, 
				  OPENBLAS_CONST blasint ldb, 
				  OPENBLAS_CONST double beta, 
				  double *C, 
				  OPENBLAS_CONST blasint ldc);
				  
void cblas_csyr2k(OPENBLAS_CONST enum CBLAS_ORDER Order, 
				  OPENBLAS_CONST enum CBLAS_UPLO Uplo,
				  OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
				  OPENBLAS_CONST blasint N, 
				  OPENBLAS_CONST blasint K, 
				  OPENBLAS_CONST void *alpha, 
				  OPENBLAS_CONST void *A, 
				  OPENBLAS_CONST blasint lda, 
				  OPENBLAS_CONST void *B, 
				  OPENBLAS_CONST blasint ldb, 
				  OPENBLAS_CONST void *beta, 
				  void *C, 
				  OPENBLAS_CONST blasint ldc);
				  
void cblas_zsyr2k(OPENBLAS_CONST enum CBLAS_ORDER Order, 
				  OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				  OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
				  OPENBLAS_CONST blasint N, 
				  OPENBLAS_CONST blasint K, 
				  OPENBLAS_CONST void *alpha, 
				  OPENBLAS_CONST void *A, 
				  OPENBLAS_CONST blasint lda, 
				  OPENBLAS_CONST void *B, 
				  OPENBLAS_CONST blasint ldb, 
				  OPENBLAS_CONST void *beta, 
				  void *C, 
				  OPENBLAS_CONST blasint ldc);

N : 矩阵C的阶数。K ：如果trans=‘N’，则矩阵A和B中的列数, 如果trans='C’或trans=‘T’, 则矩阵A和B中的行数。
alpha ： 矩阵A的比例因子。 beta : 矩阵C的比例因子。
lda : 矩阵A的前导维数（leading dimension）。 ldb :包含矩阵B的数组的前导维数。 ldc :包含矩阵C的数组的前导维数。

6. cblas_?trmm

缩放一个三角形矩阵，然后乘以一个矩阵。(AB或BA取决于Side)

void cblas_strmm(OPENBLAS_CONST enum CBLAS_ORDER Order, 
				 OPENBLAS_CONST enum CBLAS_SIDE Side, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo,
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
                 OPENBLAS_CONST enum CBLAS_DIAG Diag, 
                 OPENBLAS_CONST blasint M, 
                 OPENBLAS_CONST blasint N, 
                 OPENBLAS_CONST float alpha, 
                 OPENBLAS_CONST float *A, 
                 OPENBLAS_CONST blasint lda, 
                 float *B, 
                 OPENBLAS_CONST blasint ldb);
                 
void cblas_dtrmm(OPENBLAS_CONST enum CBLAS_ORDER Order, 
				 OPENBLAS_CONST enum CBLAS_SIDE Side, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
                 OPENBLAS_CONST enum CBLAS_DIAG Diag, 
                 OPENBLAS_CONST blasint M, 
                 OPENBLAS_CONST blasint N, 
                 OPENBLAS_CONST double alpha, 
                 OPENBLAS_CONST double *A, 
                 OPENBLAS_CONST blasint lda, 
                 double *B, 
                 OPENBLAS_CONST blasint ldb);
                 
void cblas_ctrmm(OPENBLAS_CONST enum CBLAS_ORDER Order, 
				 OPENBLAS_CONST enum CBLAS_SIDE Side, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
                 OPENBLAS_CONST enum CBLAS_DIAG Diag, 
                 OPENBLAS_CONST blasint M, 
                 OPENBLAS_CONST blasint N, 
                 OPENBLAS_CONST void *alpha, 
                 OPENBLAS_CONST void *A, 
                 OPENBLAS_CONST blasint lda, 
                 void *B, 
                 OPENBLAS_CONST blasint ldb);
                 
void cblas_ztrmm(OPENBLAS_CONST enum CBLAS_ORDER Order, 
				 OPENBLAS_CONST enum CBLAS_SIDE Side, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
                 OPENBLAS_CONST enum CBLAS_DIAG Diag, 
                 OPENBLAS_CONST blasint M, 
                 OPENBLAS_CONST blasint N, 
                 OPENBLAS_CONST void *alpha, 
                 OPENBLAS_CONST void *A, 
                 OPENBLAS_CONST blasint lda, 
                 void *B, 
                 OPENBLAS_CONST blasint ldb);

M : 矩阵B中的行数。 N : 矩阵B中的列数。 alpha : 矩阵A的比例因子。 A : 三角矩阵。
lda : 矩阵A的前导维数。 ldb : 矩阵B的前导维数。 B : 矩阵B被返回的结果覆盖。

7. cblas_?trsm

解一个右边有多个值的三角形方程组。

void cblas_strsm(OPENBLAS_CONST enum CBLAS_ORDER Order, 
				 OPENBLAS_CONST enum CBLAS_SIDE Side, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
                 OPENBLAS_CONST enum CBLAS_DIAG Diag, 
                 OPENBLAS_CONST blasint M, 
                 OPENBLAS_CONST blasint N, 
                 OPENBLAS_CONST float alpha, 
                 OPENBLAS_CONST float *A, 
                 OPENBLAS_CONST blasint lda, 
                 float *B, 
                 OPENBLAS_CONST blasint ldb);
                 
void cblas_dtrsm(OPENBLAS_CONST enum CBLAS_ORDER Order,
				 OPENBLAS_CONST enum CBLAS_SIDE Side, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
                 OPENBLAS_CONST enum CBLAS_DIAG Diag, 
                 OPENBLAS_CONST blasint M, 
                 OPENBLAS_CONST blasint N, 
                 OPENBLAS_CONST double alpha, 
                 OPENBLAS_CONST double *A, 
                 OPENBLAS_CONST blasint lda, 
                 double *B, 
                 OPENBLAS_CONST blasint ldb);
                 
void cblas_ctrsm(OPENBLAS_CONST enum CBLAS_ORDER Order, 
				 OPENBLAS_CONST enum CBLAS_SIDE Side, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
                 OPENBLAS_CONST enum CBLAS_DIAG Diag, 
                 OPENBLAS_CONST blasint M, 
                 OPENBLAS_CONST blasint N, 
                 OPENBLAS_CONST void *alpha, 
                 OPENBLAS_CONST void *A, 
                 OPENBLAS_CONST blasint lda, 
                 void *B, 
                 OPENBLAS_CONST blasint ldb);
                 
void cblas_ztrsm(OPENBLAS_CONST enum CBLAS_ORDER Order, 
				 OPENBLAS_CONST enum CBLAS_SIDE Side, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
                 OPENBLAS_CONST enum CBLAS_DIAG Diag, 
                 OPENBLAS_CONST blasint M, 
                 OPENBLAS_CONST blasint N, 
                 OPENBLAS_CONST void *alpha, 
                 OPENBLAS_CONST void *A, 
                 OPENBLAS_CONST blasint lda, 
                 void *B,
                 OPENBLAS_CONST blasint ldb);

M : 矩阵B中的行数。 N : 矩阵B中的列数。 alpha : 矩阵A的比例因子。 A : 三角矩阵。
lda : 矩阵A的前导维数。 ldb : 矩阵B的前导维数。 B : 在输入时的矩阵B。在返回时被矩阵X覆盖。

8. cblas_?hemm


两个Hermitian 矩阵相乘

void cblas_chemm(OPENBLAS_CONST enum CBLAS_ORDER Order, 
				 OPENBLAS_CONST enum CBLAS_SIDE Side, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST blasint M, 
				 OPENBLAS_CONST blasint N,
                 OPENBLAS_CONST void *alpha, 
                 OPENBLAS_CONST void *A, 
                 OPENBLAS_CONST blasint lda, 
                 OPENBLAS_CONST void *B, 
                 OPENBLAS_CONST blasint ldb, 
                 OPENBLAS_CONST void *beta, 
                 void *C, 
                 OPENBLAS_CONST blasint ldc);
                 
void cblas_zhemm(OPENBLAS_CONST enum CBLAS_ORDER Order, 
				 OPENBLAS_CONST enum CBLAS_SIDE Side, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST blasint M, 
				 OPENBLAS_CONST blasint N,
                 OPENBLAS_CONST void *alpha, 
                 OPENBLAS_CONST void *A, 
                 OPENBLAS_CONST blasint lda, 
                 OPENBLAS_CONST void *B, 
                 OPENBLAS_CONST blasint ldb, 
                 OPENBLAS_CONST void *beta, 
                 void *C, 
                 OPENBLAS_CONST blasint ldc);

M ： 矩阵A和C中的行数。 N： 矩阵B和C的列数。 K : 矩阵A的列数;矩阵B中的行数。
alpha : 矩阵A和B乘积的比例因子。beta : 矩阵C的比例因子。
lda : 矩阵A的第一个维度的大小;如果你传递一个矩阵A[m][n]，它的值应该是m。
ldb : 矩阵B的第一个维度的大小;如果你传递一个矩阵B[m][n]，它的值应该是m。
ldc : 矩阵C的第一个维度的大小;如果你传递一个矩阵C[m][n]，它的值应该是m。

9. cblas_?herk

Rank-k（rk） 更新-将Hermitian 矩阵乘以其转置，并添加第二个矩阵(单精度)。

void cblas_cherk(OPENBLAS_CONST enum CBLAS_ORDER Order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST blasint K,
                 OPENBLAS_CONST float alpha, 
                 OPENBLAS_CONST void *A, 
                 OPENBLAS_CONST blasint lda, 
                 OPENBLAS_CONST float beta, 
                 void *C, 
                 OPENBLAS_CONST blasint ldc);
                 
void cblas_zherk(OPENBLAS_CONST enum CBLAS_ORDER Order, 
				 OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				 OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans, 
				 OPENBLAS_CONST blasint N, 
				 OPENBLAS_CONST blasint K,
                 OPENBLAS_CONST double alpha, 
                 OPENBLAS_CONST void *A, 
                 OPENBLAS_CONST blasint lda, 
                 OPENBLAS_CONST double beta, 
                 void *C, 
                 OPENBLAS_CONST blasint ldc);

N : 矩阵C的阶数。 K : 矩阵A中的列数(如果矩阵A被转置，则为行数)。
lda : 包含矩阵A的数组的前导维数。ldc : 包含矩阵C的数组的前导维数。

10. cblas_?her2k

执行复Hermitian矩阵的rank-2k更新

void cblas_cher2k(OPENBLAS_CONST enum CBLAS_ORDER Order, 
				  OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				  OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans, 
				  OPENBLAS_CONST blasint N, 
				  OPENBLAS_CONST blasint K,
                  OPENBLAS_CONST void *alpha, 
                  OPENBLAS_CONST void *A, 
                  OPENBLAS_CONST blasint lda, 
                  OPENBLAS_CONST void *B, 
                  OPENBLAS_CONST blasint ldb, 
                  OPENBLAS_CONST float beta, 
                  void *C, 
                  OPENBLAS_CONST blasint ldc);
                  
void cblas_zher2k(OPENBLAS_CONST enum CBLAS_ORDER Order, 
				  OPENBLAS_CONST enum CBLAS_UPLO Uplo, 
				  OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans, 
				  OPENBLAS_CONST blasint N, 
				  OPENBLAS_CONST blasint K,
                  OPENBLAS_CONST void *alpha, 
                  OPENBLAS_CONST void *A, 
                  OPENBLAS_CONST blasint lda, 
                  OPENBLAS_CONST void *B, 
                  OPENBLAS_CONST blasint ldb, 
                  OPENBLAS_CONST double beta, 
                  void *C, 
                  OPENBLAS_CONST blasint ldc);

N : 矩阵C的阶数。K ：矩阵A和B的列数(如果矩阵A被转置或共轭，则为行数)。alpha ： 矩阵A的比例因子。
lda : 包含矩阵A的数组的前导维数。ldb : 包含矩阵B的数组的前导维数。 ldc : 包含矩阵C的数组的前导维数。beta : 矩阵C的比例因子。

BLAS扩展

1. cblas_?axpby

向量乘法

void cblas_saxpby(OPENBLAS_CONST blasint n, 
				  OPENBLAS_CONST float alpha, 
				  OPENBLAS_CONST float *x, 
				  OPENBLAS_CONST blasint incx,
				  OPENBLAS_CONST float beta, 
				  float *y,
				  OPENBLAS_CONST blasint incy);

void cblas_daxpby(OPENBLAS_CONST blasint n, 
				  OPENBLAS_CONST double alpha, 
				  OPENBLAS_CONST double *x, 
				  OPENBLAS_CONST blasint incx,
				  OPENBLAS_CONST double beta, 
				  double *y, 
				  OPENBLAS_CONST blasint incy);

void cblas_caxpby(OPENBLAS_CONST blasint n, 
				  OPENBLAS_CONST void *alpha, 
				  OPENBLAS_CONST void *x, 
				  OPENBLAS_CONST blasint incx,
				  OPENBLAS_CONST void *beta, 
				  void *y, 
				  OPENBLAS_CONST blasint incy);

void cblas_zaxpby(OPENBLAS_CONST blasint n, 
				  OPENBLAS_CONST void *alpha, 
				  OPENBLAS_CONST void *x, 
				  OPENBLAS_CONST blasint incx,
				  OPENBLAS_CONST void *beta, 
				  void *y, 
				  OPENBLAS_CONST blasint incy);

n : 向量元素个数

2. cblas_?omatcopy


向量复制

void cblas_somatcopy(OPENBLAS_CONST enum CBLAS_ORDER CORDER, 
					 OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS, 
					 OPENBLAS_CONST blasint crows, 
					 OPENBLAS_CONST blasint ccols, 
					 OPENBLAS_CONST float calpha, 
					 OPENBLAS_CONST float *a, 
					 OPENBLAS_CONST blasint clda, 
					 float *b, 
					 OPENBLAS_CONST blasint cldb); 
					 
void cblas_domatcopy(OPENBLAS_CONST enum CBLAS_ORDER CORDER, 
					 OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS, 
					 OPENBLAS_CONST blasint crows, 
					 OPENBLAS_CONST blasint ccols, 
					 OPENBLAS_CONST double calpha, 
					 OPENBLAS_CONST double *a,
					 OPENBLAS_CONST blasint clda, 
					 double *b, 
					 OPENBLAS_CONST blasint cldb); 
					 
void cblas_comatcopy(OPENBLAS_CONST enum CBLAS_ORDER CORDER, 
				     OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS, 
				     OPENBLAS_CONST blasint crows, 
				     OPENBLAS_CONST blasint ccols, 
				     OPENBLAS_CONST float* calpha, 
				     OPENBLAS_CONST float* a, 
				     OPENBLAS_CONST blasint clda, 
				     float*b, 
				     OPENBLAS_CONST blasint cldb); 
				     
void cblas_zomatcopy(OPENBLAS_CONST enum CBLAS_ORDER CORDER, 
					 OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS, 
					 OPENBLAS_CONST blasint crows, 
					 OPENBLAS_CONST blasint ccols,
					 OPENBLAS_CONST double* calpha, 
					 OPENBLAS_CONST double* a, 
					 OPENBLAS_CONST blasint clda,  
					 double *b, 
					 OPENBLAS_CONST blasint cldb);

CORDER ：行主或列主存储顺序。
CTRANS　：矩阵Ａ是否转置或共轭。
crows　：矩阵B(目标矩阵)中的行数。
ccols　：矩阵B(目标矩阵)中的列数。
calpha　：矩阵的比例因子。
a : 矩阵A。 b: 矩阵B。
clda : 矩阵A的第一个维度的大小;如果你传递一个矩阵A[m][n]，它的值应该是m。
cldb : 矩阵B的第一个维度的大小;如果你传递一个矩阵B[m][n]，它的值应该是m。

3. cblas_?imatcopy

矩阵就地（in-place）转化或复制

void cblas_simatcopy(OPENBLAS_CONST enum CBLAS_ORDER CORDER, 
					 OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS, 
					 OPENBLAS_CONST blasint crows, 
					 OPENBLAS_CONST blasint ccols, 
					 OPENBLAS_CONST float calpha, 
					 float *a, 
					 OPENBLAS_CONST blasint clda, 
					 OPENBLAS_CONST blasint cldb); 
					 
void cblas_dimatcopy(OPENBLAS_CONST enum CBLAS_ORDER CORDER, 
					 OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS, 
					 OPENBLAS_CONST blasint crows, 
					 OPENBLAS_CONST blasint ccols, 
					 OPENBLAS_CONST double calpha, 
					 double *a,
					 OPENBLAS_CONST blasint clda, 
					 OPENBLAS_CONST blasint cldb); 
					 
void cblas_cimatcopy(OPENBLAS_CONST enum CBLAS_ORDER CORDER, 
					 OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS, 
					 OPENBLAS_CONST blasint crows, 
					 OPENBLAS_CONST blasint ccols, 
					 OPENBLAS_CONST float* calpha, 
					 float* a, 
					 OPENBLAS_CONST blasint clda, 
					 OPENBLAS_CONST blasint cldb); 
					 
void cblas_zimatcopy(OPENBLAS_CONST enum CBLAS_ORDER CORDER, 
					 OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS, 
					 OPENBLAS_CONST blasint crows, 
					 OPENBLAS_CONST blasint ccols, 
					 OPENBLAS_CONST double* calpha, 
					 double* a, 
					 OPENBLAS_CONST blasint clda, 
					 OPENBLAS_CONST blasint cldb);

CORDER ：行主或列主存储顺序。
CTRANS　：矩阵Ａ是否转置或共轭。
crows　：矩阵A在转置操作之前的行数。
ccols　：矩阵A在转置操作之前的列数。
calpha　：矩阵的比例因子。
a : 矩阵A。 b: 矩阵B。
clda : 源矩阵中相邻列(列-主序)或行(行-主序)中第一个元素之间的距离;用元素的数量来衡量
cldb : 目的矩阵中相邻列的第一个元素(列-主序)或行(行-主序)之间的距离;用元素的数量来衡量。

4. cblas_?geadd

void cblas_sgeadd(OPENBLAS_CONST enum CBLAS_ORDER CORDER,
				  OPENBLAS_CONST blasint crows, 
				  OPENBLAS_CONST blasint ccols, 
				  OPENBLAS_CONST float calpha, 
				  float *a, 
				  OPENBLAS_CONST blasint clda, 
				  OPENBLAS_CONST float cbeta, 
				  float *c, 
				  OPENBLAS_CONST blasint cldc); 
				  
void cblas_dgeadd(OPENBLAS_CONST enum CBLAS_ORDER CORDER,
				  OPENBLAS_CONST blasint crows, 
				  OPENBLAS_CONST blasint ccols, 
				  OPENBLAS_CONST double calpha, 
				  double *a, 
				  OPENBLAS_CONST blasint clda, 
				  OPENBLAS_CONST double cbeta, 
				  double *c, 
				  OPENBLAS_CONST blasint cldc); 
				  
void cblas_cgeadd(OPENBLAS_CONST enum CBLAS_ORDER CORDER,
				  OPENBLAS_CONST blasint crows, 
				  OPENBLAS_CONST blasint ccols, 
				  OPENBLAS_CONST float *calpha, 
				  float *a, 
				  OPENBLAS_CONST blasint clda, 
				  OPENBLAS_CONST float *cbeta, 
				  float *c, 
				  OPENBLAS_CONST blasint cldc); 
				  
void cblas_zgeadd(OPENBLAS_CONST enum CBLAS_ORDER CORDER,
				  OPENBLAS_CONST blasint crows, 
				  OPENBLAS_CONST blasint ccols, 
				  OPENBLAS_CONST double *calpha, 
				  double *a, 
				  OPENBLAS_CONST blasint clda, 
				  OPENBLAS_CONST double *cbeta, 
				  double *c, 
				  OPENBLAS_CONST blasint cldc);

错误处理

void cblas_xerbla(blasint p, char *rout, char *form, ...);

你可能感兴趣的:(c)

  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • 【iOS】MVC设计模式 Magnetic_h iosmvc设计模式objective-c学习ui
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
  • OC语言多界面传值五大方式 Magnetic_h iosui学习objective-c开发语言
    前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
  • UI学习——cell的复用和自定义cell Magnetic_h ui学习
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
  • element实现动态路由+面包屑 软件技术NINI vue案例vue.js前端
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
  • C语言宏函数 南林yan C语言c语言
    一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
  • C语言如何定义宏函数？ 小九格物 c语言
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
  • 理解Gunicorn：Python WSGI服务器的基石 范范0825 ipythonlinux运维
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
  • Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断 尐尐呅
    结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • LocalDateTime 转 String igotyback java开发语言
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
  • swagger访问路径 igotyback swagger
    Swagger2.x版本访问地址：http://{ip}:{port}/{context-path}/swagger-ui.html{ip}是你的服务器IP地址。{port}是你的应用服务端口，通常为8080。{context-path}是你的应用上下文路径，如果应用部署在根路径下，则为空。Swagger3.x版本对于Swagger3.x版本（也称为OpenAPI3）访问地址：http://{ip
  • mysql禁用远程登录 igotyback mysql
    去mysql库中的user表里，将host都改成localhost之后刷新权限FLUSHPRIVILEGES;
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码 说私域 人工智能小程序
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
  • html 中如何使用 uniapp 的部分方法 某公司摸鱼前端 htmluni-app前端
    示例代码：Documentconsole.log(window);效果展示：好了，现在就可以uni.使用相关的方法了
  • ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值） 研学随笔 arcgis经验分享
    我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
  • 高级编程--XML+socket练习题 masa010 java开发语言
    1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
  • 水平垂直居中的几种方法（总结） LJ小番茄 CSS_玄学语言htmljavascript前端csscss3
    1.使用flexbox的justify-content和align-items.parent{display:flex;justify-content:center;/*水平居中*/align-items:center;/*垂直居中*/height:100vh;/*需要指定高度*/}2.使用grid的place-items:center.parent{display:grid;place-item
  • 回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录leetcode算法职场和发展
    重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
  • 每日一题——第八十九题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：在字符串中找到提取数字，并统计一共找到多少整数，a123xxyu23&8889，那么找到的整数为123，23，8889//思想：#include#include#includeintmain(){charstr[]="a123xxyu23&8889";intcount=0;intnum=0;//用于临时存放当前正在构建的整数。boolinNum=false;//用于标记当前是否正在读取一个整
  • 每日一题——第九十题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：判断子串是否与主串匹配#include#include#include//////判断子串是否在主串中匹配//////主串///子串///boolisSubstring(constchar*str,constchar*substr){intlenstr=strlen(str);//计算主串的长度intlenSub=strlen(substr);//计算子串的长度//遍历主字符串，对每个可能得
  • 每日一题——第八十一题 互联网打工人no1 C语言程序设计每日一练c语言
    打印如下图案:#includeintmain(){inti,j;charch='A';for(i=1;i<5;i++,ch++){for(j=0;j<5-i;j++){printf("");//控制空格输出}for(j=1;j<2*i;j++)//条件j<2*i{printf("%c",ch);//控制字符输出}printf("\n");}return0;}
  • 每日一题——第八十四题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：编写函数1、输入10个职工的姓名和职工号2、按照职工由大到小顺序排列，姓名顺序也随之调整3、要求输入一个职工号，用折半查找法找出该职工的姓名#define_CRT_SECURE_NO_WARNINGS#include#include#defineMAX_EMPLOYEES10typedefstruct{intid;charname[50];}Empolyee;voidinputEmploye
  • 每日一题——第八十二题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：将一个控制台输入的字符串中的所有元音字母复制到另一字符串中#include#include#include#include#defineMAX_INPUT1024boolisVowel(charp);intmain(){charinput[MAX_INPUT];charoutput[MAX_INPUT];printf("请输入一串字符串：\n");fgets(input,sizeof(inp
  • 每日一题——第八十三题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：将输入的整形数字输出,输出1990，输出"1990"#include#defineMAX_INPUT1024intmain(){intarrr_num[MAX_INPUT];intnum,i=0;printf("请输入一个数字：");scanf_s("%d",&num);while(num!=0){arrr_num[i++]=num%10;num/=10;}printf("\"");for(
  • C#中使用split分割字符串 互联网打工人no1 c#
    1、用字符串分隔：usingSystem.Text.RegularExpressions;stringstr="aaajsbbbjsccc";string[]sArray=Regex.Split(str,"js",RegexOptions.IgnoreCase);foreach(stringiinsArray)Response.Write(i.ToString()+"");输出结果：aaabbbc
  • WPF中的ComboBox控件几种数据绑定的方式 互联网打工人no1 wpfc#
    一、用字典给ItemsSource赋值（此绑定用的地方很多，建议熟练掌握）在XMAL中：在CS文件中privatevoidBindData(){DictionarydicItem=newDictionary();dicItem.add(1,"北京");dicItem.add(2,"上海");dicItem.add(3,"广州");cmb_list.ItemsSource=dicItem;cmb_l
  • knob UI插件使用 换个号韩国红果果 JavaScriptjsonpknob
    图形是用canvas绘制的 js代码 var paras = { max:800, min:100, skin:'tron',//button type thickness:.3,//button width width:'200',//define canvas width.,canvas height displayInput:'tr
  • Android+Jquery Mobile学习系列(5)-SQLite数据库 白糖_ JQuery Mobile
    目录导航   SQLite是轻量级的、嵌入式的、关系型数据库，目前已经在iPhone、Android等手机系统中使用,SQLite可移植性好，很容易使用，很小，高效而且可靠。   因为Android已经集成了SQLite，所以开发人员无需引入任何JAR包，而且Android也针对SQLite封装了专属的API，调用起来非常快捷方便。   我也是第一次接触S
  • impala-2.1.2-CDH5.3.2 dayutianfei impala
    最近在整理impala编译的东西，简单记录几个要点： 根据官网的信息（https://github.com/cloudera/Impala/wiki/How-to-build-Impala）： 1. 首次编译impala，推荐使用命令： ${IMPALA_HOME}/buildall.sh -skiptests -build_shared_libs -format 2.仅编译BE ${I
  • 求二进制数中1的个数 周凡杨 java算法二进制
    解法一： 对于一个正整数如果是偶数，该数的二进制数的最后一位是 0 ，反之若是奇数，则该数的二进制数的最后一位是 1 。因此，可以考虑利用位移、判断奇偶来实现。   public int bitCount(int x){ int count = 0; while(x!=0){ if(x%2!=0){ /
  • spring中hibernate及事务配置 g21121 Hibernate
    hibernate的sessionFactory配置： <!-- hibernate sessionFactory配置 --> <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <
  • log4j.properties 使用 510888780 log4j
    log4j.properties 使用 一.参数意义说明 输出级别的种类 ERROR、WARN、INFO、DEBUG ERROR 为严重错误 主要是程序的错误 WARN 为一般警告，比如session丢失 INFO 为一般要显示的信息，比如登录登出 DEBUG 为程序的调试信息 配置日志信息输出目的地 log4j.appender.appenderName = fully.qua
  • Spring mvc-jfreeChart柱图（2） 布衣凌宇 jfreechart
    上一篇中生成的图是静态的，这篇将按条件进行搜索，并统计成图表，左面为统计图，右面显示搜索出的结果。 第一步：导包 第二步；配置web.xml(上一篇有代码) 建BarRenderer类用于柱子颜色 import java.awt.Color; import java.awt.Paint; import org.jfree.chart.renderer.category.BarR
  • 我的spring学习笔记14-容器扩展点之PropertyPlaceholderConfigurer aijuans Spring3
    PropertyPlaceholderConfigurer是个bean工厂后置处理器的实现，也就是BeanFactoryPostProcessor接口的一个实现。关于BeanFactoryPostProcessor和BeanPostProcessor类似。我会在其他地方介绍。 PropertyPlaceholderConfigurer可以将上下文（配置文件）中的属性值放在另一个单独的标准java
  • maven 之 cobertura 简单使用 antlove maventestunitcoberturareport
    1. 创建一个maven项目 2. 创建com.CoberturaStart.java package com; public class CoberturaStart { public void helloEveryone(){ System.out.println("=================================================
  • 程序的执行顺序 百合不是茶 JAVA执行顺序
          刚在看java核心技术时发现对java的执行顺序不是很明白了,百度一下也没有找到适合自己的资料,所以就简单的回顾一下吧   代码如下;     经典的程序执行面试题 //关于程序执行的顺序 //例如： //定义一个基类 public class A(){ public A(
  • 设置session失效的几种方法 bijian1013 web.xmlsession失效监听器
    在系统登录后，都会设置一个当前session失效的时间，以确保在用户长时间不与服务器交互，自动退出登录，销毁session。具体设置很简单，方法有三种：（1）在主页面或者公共页面中加入：session.setMaxInactiveInterval(900);参数900单位是秒，即在没有活动15分钟后，session将失效。这里要注意这个session设置的时间是根据服务器来计算的，而不是客户端。所
  • java jvm常用命令工具 bijian1013 javajvm
    一.概述         程序运行中经常会遇到各种问题，定位问题时通常需要综合各种信息，如系统日志、堆dump文件、线程dump文件、GC日志等。通过虚拟机监控和诊断工具可以帮忙我们快速获取、分析需要的数据，进而提高问题解决速度。 本文将介绍虚拟机常用监控和问题诊断命令工具的使用方法，主要包含以下工具:       &nbs
  • 【Spring框架一】Spring常用注解之Autowired和Resource注解 bit1129 Spring常用注解
    Spring自从2.0引入注解的方式取代XML配置的方式来做IOC之后，对Spring一些常用注解的含义行为一直处于比较模糊的状态，写几篇总结下Spring常用的注解。本篇包含的注解有如下几个： Autowired Resource Component Service Controller Transactional 根据它们的功能、目的，可以分为三组，Autow
  • mysql 操作遇到safe update mode问题 bitray update
        我并不知道出现这个问题的实际原理,只是通过其他朋友的博客,文章得知的一个解决方案,目前先记录一个解决方法,未来要是真了解以后,还会继续补全.     在mysql5中有一个safe update mode,这个模式让sql操作更加安全,据说要求有where条件,防止全表更新操作.如果必须要进行全表操作,我们可以执行 SET
  • nginx_perl试用 ronin47 nginx_perl试用
    因为空闲时间比较多，所以在CPAN上乱翻，看到了nginx_perl这个项目(原名Nginx::Engine)，现在托管在github.com上。地址见：https://github.com/zzzcpan/nginx-perl 这个模块的目的，是在nginx内置官方perl模块的基础上，实现一系列异步非阻塞的api。用connector/writer/reader完成类似proxy的功能（这里
  • java-63-在字符串中删除特定的字符 bylijinnan java
    public class DeleteSpecificChars { /** * Q 63 在字符串中删除特定的字符 * 输入两个字符串，从第一字符串中删除第二个字符串中所有的字符。 * 例如，输入”They are students.”和”aeiou”，则删除之后的第一个字符串变成”Thy r stdnts.” */ public static voi
  • EffectiveJava--创建和销毁对象 ccii 创建和销毁对象
    本章内容： 1. 考虑用静态工厂方法代替构造器 2. 遇到多个构造器参数时要考虑用构建器（Builder模式） 3. 用私有构造器或者枚举类型强化Singleton属性 4. 通过私有构造器强化不可实例化的能力 5. 避免创建不必要的对象 6. 消除过期的对象引用 7. 避免使用终结方法 1. 考虑用静态工厂方法代替构造器     类可以通过
  • [宇宙时代]四边形理论与光速飞行 comsci
       从四边形理论来推论 为什么光子飞船必须获得星光信号才能够进行光速飞行？    一组星体组成星座  向空间辐射一组由复杂星光信号组成的辐射频带，按照四边形-频率假说  一组频率就代表一个时空的入口    那么这种由星光信号组成的辐射频带就代表由这些星体所控制的时空通道，该时空通道在三维空间的投影是一
  • ubuntu server下python脚本迁移数据 cywhoyi pythonKettlepymysqlcx_Oracleubuntu server
    因为是在Ubuntu下，所以安装python、pip、pymysql等都极其方便，sudo apt-get install pymysql， 但是在安装cx_Oracle（连接oracle的模块）出现许多问题，查阅相关资料，发现这边文章能够帮我解决，希望大家少走点弯路。http://www.tbdazhe.com/archives/602 1.安装python 2.安装pip、pymysql
  • Ajax正确但是请求不到值解决方案 dashuaifu Ajaxasync
    Ajax正确但是请求不到值解决方案   解决方案：1 .     async: false ,    2.     设置延时执行js里的ajax或者延时后台java方法！！！！！！！   例如：   $.ajax({     &
  • windows安装配置php+memcached dcj3sjt126com PHPInstallmemcache
    Windows下Memcached的安装配置方法 1、将第一个包解压放某个盘下面，比如在c:\memcached。 2、在终端（也即cmd命令界面）下输入 'c:\memcached\memcached.exe -d install' 安装。 3、再输入： 'c:\memcached\memcached.exe -d start' 启动。（需要注意的: 以后memcached将作为windo
  • iOS开发学习路径的一些建议 dcj3sjt126com ios
    iOS论坛里有朋友要求回答帖子，帖子的标题是： 想学IOS开发高阶一点的东西，从何开始，然后我吧啦吧啦回答写了很多。既然敲了那么多字，我就把我写的回复也贴到博客里来分享，希望能对大家有帮助。欢迎大家也到帖子里讨论和分享，地址：http://bbs.csdn.net/topics/390920759   下面是我回复的内容：   结合自己情况聊下iOS学习建议，
  • Javascript闭包概念 fanfanlovey JavaScript闭包
    1.参考资料 http://www.jb51.net/article/24101.htm http://blog.csdn.net/yn49782026/article/details/8549462 2.内容概述 要理解闭包，首先需要理解变量作用域问题 内部函数可以饮用外面全局变量 var n=999; 　　functio
  • yum安装mysql5.6 haisheng mysql
    1、安装http://dev.mysql.com/get/mysql-community-release-el7-5.noarch.rpm   2、yum install mysql   3、yum install mysql-server   4、vi /etc/my.cnf   添加character_set_server=utf8
  • po/bo/vo/dao/pojo的详介 IT_zhlp80 javaBOVODAOPOJOpo
        JAVA几种对象的解释 PO:persistant object持久对象,可以看成是与数据库中的表相映射的java对象。最简单的PO就是对应数据库中某个表中的一条记录，多个记录可以用PO的集合。PO中应该不包含任何对数据库的操作. VO:value object值对象。通常用于业务层之间的数据传递，和PO一样也是仅仅包含数据而已。但应是抽象出的业务对象,可
  • java设计模式 kerryg java设计模式
    设计模式的分类：    一、 设计模式总体分为三大类： 1、创建型模式（5种）：工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式。 2、结构型模式（7种）：适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式。 3、行为型模式（11种）：策略模式，模版方法模式，观察者模式，迭代子模式，责任链模式，命令模式，备忘录模式，状态模式，访问者
  • [1]CXF3.1整合Spring开发webservice——helloworld篇 木头.java springwebserviceCXF
    Spring 版本3.2.10 CXF 版本3.1.1 项目采用MAVEN组织依赖jar 我这里是有parent的pom，为了简洁明了，我直接把所有的依赖都列一起了，所以都没version，反正上面已经写了版本 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="ht
  • Google 工程师亲授：菜鸟开发者一定要投资的十大目标 qindongliang1922 工作感悟人生
    身为软件开发者，有什么是一定得投资的？ Google 软件工程师 Emanuel Saringan 整理了十项他认为必要的投资，第一项就是身体健康，英文与数学也都是必备能力吗？来看看他怎么说。（以下文字以作者第一人称撰写）） 你的健康 无疑地，软件开发者是世界上最久坐不动的职业之一。 每天连坐八到十六小时，休息时间只有一点点，绝对会让你的鲔鱼肚肆无忌惮的生长。肥胖容易扩大罹患其他疾病的风险，
  • linux打开最大文件数量1,048,576 tianzhihehe clinux
    File descriptors are represented by the C int type. Not using a special type is often  considered odd, but is, historically, the Unix way. Each Linux process has a maximum number of files th
  • java语言中PO、VO、DAO、BO、POJO几种对象的解释 衞酆夼 javaVOBOPOJOpo
    PO:persistant object持久对象 最形象的理解就是一个PO就是数据库中的一条记录。好处是可以把一条记录作为一个对象处理，可以方便的转为其它对象。可以看成是与数据库中的表相映射的java对象。最简单的PO就是对应数据库中某个表中的一条记录，多个记录可以用PO的集合。PO中应该不包含任何对数据库的操作。 BO:business object业务对象 封装业务逻辑的java对象
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他