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_saxpby(N, alpha, X, 1, beta, Y, 1);
}template <>
void caffe_cpu_axpby<double>(const int N, const double alpha, const double* X,const double beta, double* Y) {cblas_daxpby(N, alpha, X, 1, beta, Y, 1);
}

cblas_dscal(N, beta, Y, incY);  Y=Y*beta cblas_daxpy(N, alpha, X, incX, Y, incY);  Y= (alpha * X) + Y)

Y=alpha * X + Y

template <>
void caffe_axpy<float>(const int N, const float alpha, const float* X,float* Y) { cblas_saxpy(N, alpha, X, 1, Y, 1); }template <>
void caffe_axpy<double>(const int N, const double alpha, const double* X,double* Y) { cblas_daxpy(N, alpha, X, 1, Y, 1); }

DEFINE_VSL_BINARY_FUNC(Add, y[i] = a[i] + b[i]);
DEFINE_VSL_BINARY_FUNC(Sub, y[i] = a[i] - b[i]);
DEFINE_VSL_BINARY_FUNC(Mul, y[i] = a[i] * b[i]);
DEFINE_VSL_BINARY_FUNC(Div, y[i] = a[i] / b[i]);template <>
void caffe_add<float>(const int n, const float* a, const float* b,
float* y) {
vsAdd(n, a, b, y);
}template <>
void caffe_add<double>(const int n, const double* a, const double* b,
double* y) {
vdAdd(n, a, b, y);
}

y=x;

template <>
void caffe_copy<float>(const int N, const float* X, float* Y) {cblas_scopy(N, X, 1, Y, 1);
}template <>
void caffe_copy<double>(const int N, const double* X, double* Y) {cblas_dcopy(N, X, 1, Y, 1);
}template <>
void caffe_gpu_copy<float>(const int N, const float* X, float* Y) {CUBLAS_CHECK(cublasScopy(Caffe::cublas_handle(), N, X, 1, Y, 1));
}template <>
void caffe_gpu_copy<double>(const int N, const double* X, double* Y) {CUBLAS_CHECK(cublasDcopy(Caffe::cublas_handle(), N, X, 1, Y, 1));
}

Computes alpha*x*y' + A.

cblas_sger
Multiplies vector X by the transform of vector Y, then adds matrix A (single precison).

Multiplies vector X by the transform of vector Y, then adds matrix A (single precison).void cblas_sger (const enum CBLAS_ORDER Order,const int M,const int N,const float alpha,const float *X,const int incX,const float *Y,const int incY,float *A,const int lda);Y(vetor)←αAX + βY

This function multiplies A * X (after transposing A, if needed) and multiplies the resulting matrix by alpha.
It then multiplies vector Y by beta. It stores the sum of these two products in vector Y.

template <>
void caffe_cpu_gemv<float>(const CBLAS_TRANSPOSE TransA, const int M,const int N, const float alpha, const float* A, const float* x,const float beta, float* y) {cblas_sgemv(CblasRowMajor, TransA, M, N, alpha, A, N, x, 1, beta, y, 1);
}

C(matrix)←αAB + βC

template<typename T>
void gpu_multmat(T* A, T* B, T* C, int M,int K,int N){const T alpha = 1,beta=0;caffe_gpu_gemm(CblasNoTrans,CblasNoTrans,M,N,K,alpha,A,B,beta,C);
}

template<>
void caffe_cpu_gemm<float>(const CBLAS_TRANSPOSE TransA,const CBLAS_TRANSPOSE TransB, const int M, const int N, const int K,const float alpha, const float* A, const float* B, const float beta,float* C) {int lda = (TransA == CblasNoTrans) ? K : M;int ldb = (TransB == CblasNoTrans) ? N : K;cblas_sgemm(CblasRowMajor, TransA, TransB, M, N, K, alpha, A, lda, B,ldb, beta, C, N);
}

A=M*N  B=M*K
C=A'*B   N M K

template<typename T>
void cpu_multTmat(T* A, T* B, T* C, int M,int K,int N){const T alpha = 1,beta=0;caffe_cpu_gemm(CblasTrans,CblasNoTrans,M,N,K,alpha,A,B,beta,C);// cblas_dgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, M, N, K, alpha, A, M, B,    K, beta, C, M);
}

A=M*N B=N*K

C=A*B   M N K

template<typename T>
void cpu_multmat(T* A, T* B, T* C, int M,int K,int N){const T alpha = 1,beta=0;caffe_cpu_gemm(CblasNoTrans,CblasNoTrans,M,N,K,alpha,A,B,beta,C);// cblas_dgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, M, N, K, alpha, A, M, B,    K, beta, C, M);
}

计算矩阵乘法的函数之一是 cblas_sgemm，使用单精度实数，另外还有对应双精度实数，单精度复数和双精度复数的函数。在此以 cblas_sgemm为例。函数定义为：void cblas_sgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA,const enum CBLAS_TRANSPOSE TransB, const int M, const int N,const int K, const float alpha, const float  *A,const int lda, const float  *B, const int ldb,const float beta, float  *C, const int ldc)得到的结果是: C = alpha*op( A )*op( B ) + beta*Cconst enum CBLAS_ORDER Order，这是指的数据的存储形式，在CBLAS的函数中无论一维还是二维数据都是用一维数组存储，这就要涉及是行主序还是列主序，在C语言中数组是用 行主序，fortran中是列主序。我还是习惯于是用行主序，所以这个参数是用CblasRowMajor，如果是列主序的话就是 CblasColMajor。const int M，矩阵A的行，矩阵C的行const int N，矩阵B的列，矩阵C的列const int K，矩阵A的列，矩阵B的行const float alpha， const float beta，计算公式中的两个参数值，如果只是计算C=A*B，则alpha=1,beta=0const float  *A， const float  *B， const float  *C，矩阵ABC的数据const int lda， const int ldb， const int ldc，在BLAS的文档里，这三个参数分别为ABC的行数，但是实际使用发现，在CBLAS里应该是列数。