OpenBlas API整理

最新推荐文章于 2024-04-25 15:50:14 发布
最新推荐文章于 2024-04-25 15:50:14 发布
阅读量6k 收藏 38
点赞数 13
分类专栏： c 文章标签： blas
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43800762/article/details/87811697
版权

关键字

关键字英文描述中文描述
sreal, single precision实数单精度
dreal, double precision实数双精度
ccomplex, single precision复数单精度
zcomplex, double precision复数双精度
gegeneral matrix一般矩阵
gbgeneral band matrix一般带状矩阵
sysymmetric matrix对称矩阵
spsymmetric matrix (packed storage)对称矩阵(压缩存储)
sbsymmetric band matrix对称带状矩阵
mvmatrix-vector product矩阵向量乘积
svsolving a system of linear equations with a single unknown vector求解含有一个未知向量解线性方程组
mmmatrix-matrix product矩阵矩阵乘积
smsolving a system of linear equations with multiple unknown vectors求解含有多个未知向量的线性方程组
trtriangular matrix三角矩阵
tptriangular matrix (packed storage)三角矩阵（压缩存储
tbtriangular 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_?asums, d, sc, dz矢量大小和(函数)
cblas_?axpys, d, c, z标量-向量乘积(例程)
cblas_?copys, d, c, z拷贝向量(例程)
cblas_?dots, d点积(函数)
cblas_?sdotsd, d双精度点积（函数）
cblas_?dotcc, z共轭点积（函数）
cblas_?dotuc, z非共轭点积（函数)
cblas_?nrm2s, d, sc, dz向量的2范数(欧几里得范数)(函数)
cblas_?rots, d, cs, zd点平面旋转(例程)
cblas_?rotgs, d, c, z生成Givens旋转点（例程）
cblas_?rotms, d修改Givens旋转平面中的点（例程
cblas_?rotmgs, d生成修改后的Givens平面旋转点（例程）
cblas_?scals, d, c, z, cs, zd向量-标量点积（例程）
cblas_?swaps, d, c, z向量交换(例程)
cblas_i?amaxs, d, c, z向量最大绝对值元素的索引(函数)
cblas_i?amins, d, c, z向量最小绝对值元素的索引(函数)
cblas_?cabs1s, 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_?gbmvs, d, c, z矩阵-向量乘积使用一个普通的带状矩阵
cblas?_gemvs,d,c,z矩阵和向量的乘积
cblas_?gers,d一般矩阵的Rank-1更新
cblas_?gercc,z共轭一般矩阵的Rank-1更新
cblas_?geruc,z非共轭一般矩阵的Rank-1更新
cblas_?hbmvc,z矩阵-向量乘积使用埃尔米特带状矩阵
cblas_?hemvc,z矩阵-向量乘积使用埃尔米特矩阵
cblas_?herc,z埃尔米特矩阵的Rank-1更新
cblas_?her2c,z埃尔米特矩阵的Rank-2更新
cblas_?hprc,z埃尔米特压缩矩阵的Rank-1更新
cblas_?hpr2c,z埃尔米特压缩矩阵的Rank-2更新
cblas_?sbmvc,z矩阵-向量乘积使用对称带状矩阵
cblas_?spmvs,d矩阵-向量乘积使用对称带状压缩矩阵
cblas_?sprs,d对称压缩矩阵的Rank-1更新
cblas_?spr2s,d对称压缩矩阵的Rank-2更新
cblas_?symvs,d矩阵-向量乘积使用对称矩阵
cblas_?syrs,d对称矩阵的Rank-1更新
cblas_?syr2s,d对称矩阵的Rank-2更新
cblas_?tbmvs, d, c, z矩阵和向量的乘积使用三角形带状矩阵
cblas_?tbsvs, d, c, z三角形带状矩阵线性方程组的解
cblas_?tpmvs, d, c, z矩阵和向量的乘积使用三角形压缩矩阵
cblas_?tpsvs, d, c, z三角形压缩矩阵线性方程组的解
cblas_?trmvs, d, c, z矩阵和向量的乘积使用三角形矩阵
cblas_?trsvs, 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_?gemms, d, c, z用一般矩阵计算矩阵与矩阵的乘积。
cblas_?hemmc, z计算矩阵与矩阵的乘积，其中一个输入矩阵是埃尔米特矩阵。
cblas_?herkc, z埃尔米特矩阵的Rank-k更新
cblas_?her2kc, z埃尔米特矩阵的Rank-2k更新
cblas_?symms, d, c, z计算一个矩阵-矩阵乘积，其中一个输入矩阵是对称的。
cblas_?syrks, d, c, z对称矩阵的Rank-k更新
cblas_?syr2ks, d, c, z对称矩阵的Rank-2k更新
cblas_?trmms, d, c, z计算矩阵与矩阵的乘积，其中一个输入矩阵是三角形的。
cblas_?trsms, 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, ...);
天地传奇3
关注
  • 13
    点赞
  • 踩
  • 38
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
OpenBLAS的window安装包
01-24
OpenBLAS的源码，适用于window环境，有需要可下载。。
MKL学习——向量操作
风翼冰舟的博客
04-13 1万+
前言推荐两个比较好的教程:BLAS (Basic Linear Algebra Subprograms) LAPACK for Windows命名规范BLAS基本线性代数子程序的函数命令都有一定规范，便于记忆<character> <name> <mod> ()character定义的是数据类型 s 实数域，单精度 c 复数域，单精度 d 实数域，双精度 z 复数域，双
OpenBLAS
最新发布
jasonhongcn的专栏
04-25 254
此外，OpenBLAS还针对特定CPU进行了优化，例如针对龙芯3A CPU的优化工作，显著提高了BLAS 3级函数的性能。OpenBLAS是BLAS标准的一种具体实现，致力于提供快速、可移植且多线程的BLAS实现，以满足大规模科学计算和数据分析的需求。这使得OpenBLAS不仅仅是一个基本的数学库，而是一个完整的解决方案，能够处理从简单到复杂的线性代数任务。总的来说，OpenBLAS是一个高性能的线性代数计算库，适用于各种科学计算和数据分析任务，特别是那些需要大规模并行处理的任务。
BLAS线性代数库(OpenBLAS)
hxxjxw的博客
08-02 1387
OpenBLAS是一个开源的线性代数库，高效实现了BLAS(Basic Linear Algebra Subprograms)和LAPACK(Linear Algebra PACKage)接口定义的函数
openblas使用
hohoyu的专栏
08-22 663
1、复制cblas.h、openblas_config.h、libopenblas.lib到项目文件夹，与源代码同文件夹；4、在该程序的属性中按如下添加lib和h所在的文件夹为附加库目录。2、复制libopenblas.dll到debug文件夹；5、按下图将上述lib文件添加为附加依赖项。6、在代码中添加对cblas.h的引用即可。3、在项目头文件下导入上述两个.h文件；
BLAS 1级例程(向量-向量操作)
菜牙
06-14 4753
BLAS 1级例程(向量-向量操作) cblas_?asum(计算向量元素的大小之和) float *res = cblas_sasum (const MKL_INT n, const float *x, const MKL_INT incx); float *res = cblas_scasum (const MKL_INT n, const void *x, const MKL_INT incx); double *res = cblas_dasum (const MKL_INT n, const
openBLAS API整理（函数及关键字说明）
09-14
关键字：S D C Z CS 和 ZD的含义 一级向量-向量、二级矩阵-向量、三级矩阵-矩阵各个API（函数）的含义。
openblas-0.3.19-1.5.7-API文档-中英对照版.zip
07-03
包含翻译后的API文档：openblas-0.3.19-1.5.7-javadoc-API文档-中文(简体)-英语-对照版.zip； Maven坐标：org.bytedeco:openblas:0.3.19-1.5.7； 标签：bytedeco、openblas、中英对照文档、jar包、java； 使用方法：...
openblas-0.3.13-1.5.5-API文档-中文版.zip
07-03
包含翻译后的API文档：openblas-0.3.13-1.5.5-javadoc-API文档-中文(简体)版.zip； Maven坐标：org.bytedeco:openblas:0.3.13-1.5.5； 标签：bytedeco、openblas、中文文档、jar包、java； 使用方法：解压翻译后的...
openblas-0.2.20-1.4.1-API文档-中文版.zip
06-26
包含翻译后的API文档：openblas-0.2.20-1.4.1-javadoc-API文档-中文(简体)版.zip； Maven坐标：org.bytedeco.javacpp-presets:openblas:0.2.20-1.4.1； 标签：bytedeco、javacpp、presets、openblas、中文文档、jar...
OpenBLAS-0.3.20源码
07-19
BLAS（Basic Linear Algebra Subprograms 基础线性代数程序集）是一个应用程序接口（API）标准，用以规范发布基础线性代数操作的数值库（如矢量或矩阵乘法），OpenBLAS是BLAS标准的一种具体实现。
Openblas 下载和使用方法
weixin_45206081的博客
02-13 1864
Openblas 下载及使用，快速上手
BLAS 1级例程 （矢量操作）
范fun的博客
07-26 1482
Inter MKL数学内核库，BLAS 1级例程 介绍 ......
openblas 矩阵算法库 简介
whatday的专栏
02-06 4277
openblas是一个开源的矩阵计算库，包含了诸多的精度和形式的矩阵计算算法。就精度而言，包括float和double，两种数据类型的数据，其矩阵调用函数也是不一样。不同矩阵，其计算方式也是有所不同，（姑且认为向量也是一维矩阵），例如，向量与向量之间的计算，向量与矩阵之间的计算，矩阵与矩阵之间的计算。 按照不同的计算需求openblas有如下几种 1 向量与向量 对于不同的精度，使用的函数也是不一样。例如cblasdaxpy表示double类型数据，cblasdaxpy表示float类型数据.
常用 blas 函数
aocandr8991的博客
08-02 332
Y=alpha * X +beta*Y template <> void caffe_cpu_axpby<float>(const int N, const float alpha, const float* X, const float beta, float* Y) { cblas_...
OpenBlas 安装
朝花夕拾
08-19 1万+
OpenBLAS是BLAS（Basic Linear Algebra Subprograms）的优化版。 OpenBLAS官网：http://www.openblas.net/ OpenBLAS公开课：https://www.leiphone.com/news/201704/Puevv3ZWxn0heoEv.html OpenBLAS用户手册：https://github.com/xianyi/O...
Anaconda安装OpenBLAS
真正的大师，永远怀着一颗学徒的❤
06-06 1980
安装完成后，就可以在Python环境中导入NumPy或其他依赖OpenBLAS库的科学计算库，并使用OpenBLAS库提供的高性能矩阵操作和计算功能。这个命令会从conda-forge频道中下载并安装OpenBLAS库及其依赖项。验证OpenBLAS是否正确安装。是指要安装的OpenBLAS版本号，例如0.3.12等。是OpenBLAS库的路径。
openblas第一弹:openblas 使用说明和常用接口介绍
热门推荐
Binbin_Sun的博客
03-02 2万+
openblas 使用说明 openblas 是一个开源的矩阵计算库，包含了诸多的精度和形式的矩阵计算算法。就精度而言，包括float和double，两种数据类型的数据，其矩阵调用函数也是不一样。不同矩阵，其计算方式也是有所不同，（姑且认为向量也是一维矩阵），例如，向量与向量之间的计算，向量与矩阵之间的计算，矩阵与矩阵之间的计算。 按照不同的计算需求openblas有如下几种 1. 第一...
openblas文档
10-22
OpenBLAS是一个开源的基于BLAS（Basic Linear Algebra Subprograms）的数学库，能够提供高性能的矩阵运算和线性代数操作。 OpenBLAS的文档提供了详细的使用说明和API文档，帮助用户了解和使用OpenBLAS库的各种功能。文档包括以下内容： 1. 安装指南：说明了如何下载、编译和安装OpenBLAS库，包括各个操作系统的安装步骤和配置文件设置。 2. 快速入门：介绍了OpenBLAS的基本概念和用法。包括如何创建和操作矩阵、向量的输入输出、线性代数运算的调用方法等。 3. API文档：详细介绍了OpenBLAS库的所有函数和数据结构，包括函数的原型、参数说明、返回值等。用户可以根据自己的需求选择合适的函数进行调用。 4. 性能优化：给出了一些性能优化的技巧和建议，帮助用户在使用OpenBLAS时达到最佳的性能表现。介绍了如何使用多线程、向量化等技术来提高计算速度。 5. 示例代码：提供了一些示例代码，展示了如何使用OpenBLAS进行常见的线性代数计算，如矩阵乘法、矩阵分解等。用户可以通过示例代码来学习和理解OpenBLAS的使用方法。 OpenBLAS文档的编写目的是帮助用户快速上手并充分利用库的功能，提供了全面的信息和示例，使用户能够灵活地使用OpenBLAS进行数学计算。同时，文档还提供了性能优化的建议，让用户能够根据自己的需求做出最佳的选择。无论是新手还是有经验的用户，都可以通过文档了解和使用OpenBLAS库。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值