Fix parameters

Critsium-xy · Critsium-xy · commit 399e1dde29f2 · 2024-12-04T19:04:17.000+08:00
diff --git a/source/module_base/blas_connector.cpp b/source/module_base/blas_connector.cpp
@@ -58,7 +58,7 @@ void BlasConnector::axpy( const int n, const float alpha, const float *X, const
 	}
 	else if (device_type == base_device::AbacusDevice_t::GpuDevice){
 #ifdef __CUDA
-		cublasErrcheck(cublasSaxpy(cublas_handle, n, alpha, X, incX, Y, incY));
+		cublasErrcheck(cublasSaxpy(cublas_handle, n, &alpha, X, incX, Y, incY));
 #endif
 	}
 }
@@ -70,7 +70,7 @@ void BlasConnector::axpy( const int n, const double alpha, const double *X, cons
 	}
 	else if (device_type == base_device::AbacusDevice_t::GpuDevice){
 #ifdef __CUDA
-		cublasErrcheck(cublasDaxpy(cublas_handle, n, alpha, X, incX, Y, incY));
+		cublasErrcheck(cublasDaxpy(cublas_handle, n, &alpha, X, incX, Y, incY));
 #endif
 	}
 }
@@ -82,7 +82,7 @@ void BlasConnector::axpy( const int n, const std::complex<float> alpha, const st
 	}
 	else if (device_type == base_device::AbacusDevice_t::GpuDevice){
 #ifdef __CUDA
-		cublasErrcheck(cublasCaxpy(cublas_handle, n, alpha, X, incX, Y, incY));
+		cublasErrcheck(cublasCaxpy(cublas_handle, n, &alpha, X, incX, Y, incY));
 #endif
 	}
 }
@@ -94,7 +94,7 @@ void BlasConnector::axpy( const int n, const std::complex<double> alpha, const s
 	}
 	else if (device_type == base_device::AbacusDevice_t::GpuDevice){
 #ifdef __CUDA
-		cublasErrcheck(cublasZaxpy(cublas_handle, n, alpha, X, incX, Y, incY));
+		cublasErrcheck(cublasZaxpy(cublas_handle, n, &alpha, X, incX, Y, incY));
 #endif
 	}
 }
@@ -108,7 +108,7 @@ void BlasConnector::scal( const int n,  const float alpha, float *X, const int i
 	}
 	else if (device_type == base_device::AbacusDevice_t::GpuDevice) {
 #ifdef __CUDA
-		cublasErrcheck(cublasSscal(cublas_handle, n, (float2*)alpha, (float2*)X, incx));
+		cublasErrcheck(cublasSscal(cublas_handle, n, (float2*)alpha, (float2*)X, incX));
 #endif
 	}
 }
@@ -120,7 +120,7 @@ void BlasConnector::scal( const int n, const double alpha, double *X, const int
 	}
 	else if (device_type == base_device::AbacusDevice_t::GpuDevice) {
 #ifdef __CUDA
-		cublasErrcheck(cublasDscal(cublas_handle, n, (double2*)alpha, (double2*)X, incx));
+		cublasErrcheck(cublasDscal(cublas_handle, n, (double2*)alpha, (double2*)X, incX));
 #endif
 	}
 }
@@ -132,7 +132,7 @@ void BlasConnector::scal( const int n, const std::complex<float> alpha, std::com
 	}
 	else if (device_type == base_device::AbacusDevice_t::GpuDevice) {
 #ifdef __CUDA
-		cublasErrcheck(cublasCscal(cublas_handle, n, (float2*)alpha, (float2*)X, incx));
+		cublasErrcheck(cublasCscal(cublas_handle, n, (float2*)alpha, (float2*)X, incX));
 #endif
 	}
 }
@@ -144,7 +144,7 @@ void BlasConnector::scal( const int n, const std::complex<double> alpha, std::co
 	}
 	else if (device_type == base_device::AbacusDevice_t::GpuDevice) {
 #ifdef __CUDA
-		cublasErrcheck(cublasZscal(cublas_handle, n, (double2*)alpha, (double2*)X, incx));
+		cublasErrcheck(cublasZscal(cublas_handle, n, (double2*)alpha, (double2*)X, incX));
 #endif
 	}
 }
@@ -159,7 +159,7 @@ float BlasConnector::dot( const int n, const float *X, const int incX, const flo
 	else if (device_type == base_device::AbacusDevice_t::GpuDevice){
 #ifdef __CUDA
 		float result = 0.0;
-		cublasErrcheck(cublasSdot(cublas_handle, n, X, incx, Y, incy, &result));
+		cublasErrcheck(cublasSdot(cublas_handle, n, X, incX, Y, incY, &result));
 		return result;
 #endif
 	}
@@ -174,7 +174,7 @@ double BlasConnector::dot( const int n, const double *X, const int incX, const d
 	else if (device_type == base_device::AbacusDevice_t::GpuDevice){
 #ifdef __CUDA
 		double result = 0.0;
-		cublasErrcheck(cublasDdot(cublas_handle, n, X, incx, Y, incy, &result));
+		cublasErrcheck(cublasDdot(cublas_handle, n, X, incX, Y, incY, &result));
 		return result;
 #endif
 	}
@@ -283,61 +283,61 @@ void BlasConnector::gemm(const char transa, const char transb, const int m, cons
 }
 
 void BlasConnector::gemv(const char trans, const int m, const int n,
-    const float alpha, const float* A, const int lda, const float* X, const int incx,
-    const float beta, float* Y, const int incy, base_device::AbacusDevice_t device_type)
+    const float alpha, const float* A, const int lda, const float* X, const int incX,
+    const float beta, float* Y, const int incY, base_device::AbacusDevice_t device_type)
 {
 	if (device_type == base_device::AbacusDevice_t::CpuDevice) {
-    	sgemv_(&trans, &m, &n, &alpha, A, &lda, X, &incx, &beta, Y, &incy);
+    	sgemv_(&trans, &m, &n, &alpha, A, &lda, X, &incX, &beta, Y, &incY);
 	}
 	else if (device_type == base_device::AbacusDevice_t::GpuDevice) {
 #ifdef __CUDA
 		cublasOperation_t cutrans = judge_trans_op(false, trans, "gemv_op");
-    	cublasErrcheck(cublasSgemv(cublas_handle, cutrans, m, n, alpha, A, lda, X, incx, beta, Y, incy));
+    	cublasErrcheck(cublasSgemv(cublas_handle, cutrans, m, n, alpha, A, lda, X, incX, beta, Y, incY));
 #endif
 	}
 }
 
 void BlasConnector::gemv(const char trans, const int m, const int n,
-    const double alpha, const double* A, const int lda, const double* X, const int incx,
-    const double beta, double* Y, const int incy, base_device::AbacusDevice_t device_type)
+    const double alpha, const double* A, const int lda, const double* X, const int incX,
+    const double beta, double* Y, const int incY, base_device::AbacusDevice_t device_type)
 {
 	if (device_type == base_device::AbacusDevice_t::CpuDevice) {
-    	dgemv_(&trans, &m, &n, &alpha, A, &lda, X, &incx, &beta, Y, &incy);
+    	dgemv_(&trans, &m, &n, &alpha, A, &lda, X, &incX, &beta, Y, &incY);
 	}
 	else if (device_type == base_device::AbacusDevice_t::GpuDevice) {
 #ifdef __CUDA
 		cublasOperation_t cutrans = judge_trans_op(false, trans, "gemv_op");
-    	cublasErrcheck(cublasDgemv(cublas_handle, cutrans, m, n, alpha, A, lda, X, incx, beta, Y, incy));
+    	cublasErrcheck(cublasDgemv(cublas_handle, cutrans, m, n, alpha, A, lda, X, incX, beta, Y, incY));
 #endif
 	}
 }
 
 void BlasConnector::gemv(const char trans, const int m, const int n,
-    const std::complex<float> alpha, const std::complex<float> *A, const int lda, const std::complex<float> *X, const int incx,
-    const std::complex<float> beta, std::complex<float> *Y, const int incy, base_device::AbacusDevice_t device_type)
+    const std::complex<float> alpha, const std::complex<float> *A, const int lda, const std::complex<float> *X, const int incX,
+    const std::complex<float> beta, std::complex<float> *Y, const int incY, base_device::AbacusDevice_t device_type)
 {
 	if (device_type == base_device::AbacusDevice_t::CpuDevice) {
-    	cgemv_(&trans, &m, &n, &alpha, A, &lda, X, &incx, &beta, Y, &incy);
+    	cgemv_(&trans, &m, &n, &alpha, A, &lda, X, &incX, &beta, Y, &incY);
 	}
 	else if (device_type == base_device::AbacusDevice_t::GpuDevice) {
 #ifdef __CUDA
 		cublasOperation_t cutrans = judge_trans_op(false, trans, "gemv_op");
-    	cublasErrcheck(cublasCgemv(cublas_handle, cutrans, m, n, alpha, A, lda, X, incx, beta, Y, incy));
+    	cublasErrcheck(cublasCgemv(cublas_handle, cutrans, m, n, alpha, A, lda, X, incX, beta, Y, incY));
 #endif
 	}
 }
 
 void BlasConnector::gemv(const char trans, const int m, const int n,
-    const std::complex<double> alpha, const std::complex<double> *A, const int lda, const std::complex<double> *X, const int incx,
-    const std::complex<double> beta, std::complex<double> *Y, const int incy, base_device::AbacusDevice_t device_type)
+    const std::complex<double> alpha, const std::complex<double> *A, const int lda, const std::complex<double> *X, const int incX,
+    const std::complex<double> beta, std::complex<double> *Y, const int incY, base_device::AbacusDevice_t device_type)
 {
 	if (device_type == base_device::AbacusDevice_t::CpuDevice) {
-    	zgemv_(&trans, &m, &n, &alpha, A, &lda, X, &incx, &beta, Y, &incy);
+    	zgemv_(&trans, &m, &n, &alpha, A, &lda, X, &incX, &beta, Y, &incY);
 	}
 	else if (device_type == base_device::AbacusDevice_t::GpuDevice) {
 #ifdef __CUDA
 		cublasOperation_t cutrans = judge_trans_op(false, trans, "gemv_op");
-    	cublasErrcheck(cublasZgemv(cublas_handle, cutrans, m, n, alpha, A, lda, X, incx, beta, Y, incy));
+    	cublasErrcheck(cublasZgemv(cublas_handle, cutrans, m, n, alpha, A, lda, X, incX, beta, Y, incY));
 #endif
 	}
 }
@@ -371,16 +371,16 @@ double BlasConnector::nrm2( const int n, const std::complex<double> *X, const in
 }
 
 // copies a into b
-void BlasConnector::copy(const long n, const double *a, const int incx, double *b, const int incy, base_device::AbacusDevice_t device_type)
+void BlasConnector::copy(const long n, const double *a, const int incX, double *b, const int incY, base_device::AbacusDevice_t device_type)
 {
 	if (device_type == base_device::AbacusDevice_t::CpuDevice) {
-		dcopy_(&n, a, &incx, b, &incy);
+		dcopy_(&n, a, &incX, b, &incY);
 	}
 }
 
-void BlasConnector::copy(const long n, const std::complex<double> *a, const int incx, std::complex<double> *b, const int incy, base_device::AbacusDevice_t device_type)
+void BlasConnector::copy(const long n, const std::complex<double> *a, const int incX, std::complex<double> *b, const int incY, base_device::AbacusDevice_t device_type)
 {
 	if (device_type == base_device::AbacusDevice_t::CpuDevice) {
-		zcopy_(&n, a, &incx, b, &incy);
+		zcopy_(&n, a, &incX, b, &incY);
 	}
 }

Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ void BlasConnector::axpy( const int n, const float alpha, const float *X, const`
`58`	`58`	`}`
`59`	`59`	`else if (device_type == base_device::AbacusDevice_t::GpuDevice){`
`60`	`60`	`#ifdef __CUDA`
`61`		`- cublasErrcheck(cublasSaxpy(cublas_handle, n, alpha, X, incX, Y, incY));`
	`61`	`+ cublasErrcheck(cublasSaxpy(cublas_handle, n, &alpha, X, incX, Y, incY));`
`62`	`62`	`#endif`
`63`	`63`	`}`
`64`	`64`	`}`
`@@ -70,7 +70,7 @@ void BlasConnector::axpy( const int n, const double alpha, const double *X, cons`
`70`	`70`	`}`
`71`	`71`	`else if (device_type == base_device::AbacusDevice_t::GpuDevice){`
`72`	`72`	`#ifdef __CUDA`
`73`		`- cublasErrcheck(cublasDaxpy(cublas_handle, n, alpha, X, incX, Y, incY));`
	`73`	`+ cublasErrcheck(cublasDaxpy(cublas_handle, n, &alpha, X, incX, Y, incY));`
`74`	`74`	`#endif`
`75`	`75`	`}`
`76`	`76`	`}`
`@@ -82,7 +82,7 @@ void BlasConnector::axpy( const int n, const std::complex<float> alpha, const st`
`82`	`82`	`}`
`83`	`83`	`else if (device_type == base_device::AbacusDevice_t::GpuDevice){`
`84`	`84`	`#ifdef __CUDA`
`85`		`- cublasErrcheck(cublasCaxpy(cublas_handle, n, alpha, X, incX, Y, incY));`
	`85`	`+ cublasErrcheck(cublasCaxpy(cublas_handle, n, &alpha, X, incX, Y, incY));`
`86`	`86`	`#endif`
`87`	`87`	`}`
`88`	`88`	`}`
`@@ -94,7 +94,7 @@ void BlasConnector::axpy( const int n, const std::complex<double> alpha, const s`
`94`	`94`	`}`
`95`	`95`	`else if (device_type == base_device::AbacusDevice_t::GpuDevice){`
`96`	`96`	`#ifdef __CUDA`
`97`		`- cublasErrcheck(cublasZaxpy(cublas_handle, n, alpha, X, incX, Y, incY));`
	`97`	`+ cublasErrcheck(cublasZaxpy(cublas_handle, n, &alpha, X, incX, Y, incY));`
`98`	`98`	`#endif`
`99`	`99`	`}`
`100`	`100`	`}`
`@@ -108,7 +108,7 @@ void BlasConnector::scal( const int n, const float alpha, float *X, const int i`
`108`	`108`	`}`
`109`	`109`	`else if (device_type == base_device::AbacusDevice_t::GpuDevice) {`
`110`	`110`	`#ifdef __CUDA`
`111`		`- cublasErrcheck(cublasSscal(cublas_handle, n, (float2)alpha, (float2)X, incx));`
	`111`	`+ cublasErrcheck(cublasSscal(cublas_handle, n, (float2)alpha, (float2)X, incX));`
`112`	`112`	`#endif`
`113`	`113`	`}`
`114`	`114`	`}`
`@@ -120,7 +120,7 @@ void BlasConnector::scal( const int n, const double alpha, double *X, const int`
`120`	`120`	`}`
`121`	`121`	`else if (device_type == base_device::AbacusDevice_t::GpuDevice) {`
`122`	`122`	`#ifdef __CUDA`
`123`		`- cublasErrcheck(cublasDscal(cublas_handle, n, (double2)alpha, (double2)X, incx));`
	`123`	`+ cublasErrcheck(cublasDscal(cublas_handle, n, (double2)alpha, (double2)X, incX));`
`124`	`124`	`#endif`
`125`	`125`	`}`
`126`	`126`	`}`
`@@ -132,7 +132,7 @@ void BlasConnector::scal( const int n, const std::complex<float> alpha, std::com`
`132`	`132`	`}`
`133`	`133`	`else if (device_type == base_device::AbacusDevice_t::GpuDevice) {`
`134`	`134`	`#ifdef __CUDA`
`135`		`- cublasErrcheck(cublasCscal(cublas_handle, n, (float2)alpha, (float2)X, incx));`
	`135`	`+ cublasErrcheck(cublasCscal(cublas_handle, n, (float2)alpha, (float2)X, incX));`
`136`	`136`	`#endif`
`137`	`137`	`}`
`138`	`138`	`}`
`@@ -144,7 +144,7 @@ void BlasConnector::scal( const int n, const std::complex<double> alpha, std::co`
`144`	`144`	`}`
`145`	`145`	`else if (device_type == base_device::AbacusDevice_t::GpuDevice) {`
`146`	`146`	`#ifdef __CUDA`
`147`		`- cublasErrcheck(cublasZscal(cublas_handle, n, (double2)alpha, (double2)X, incx));`
	`147`	`+ cublasErrcheck(cublasZscal(cublas_handle, n, (double2)alpha, (double2)X, incX));`
`148`	`148`	`#endif`
`149`	`149`	`}`
`150`	`150`	`}`
`@@ -159,7 +159,7 @@ float BlasConnector::dot( const int n, const float *X, const int incX, const flo`
`159`	`159`	`else if (device_type == base_device::AbacusDevice_t::GpuDevice){`
`160`	`160`	`#ifdef __CUDA`
`161`	`161`	`float result = 0.0;`
`162`		`- cublasErrcheck(cublasSdot(cublas_handle, n, X, incx, Y, incy, &result));`
	`162`	`+ cublasErrcheck(cublasSdot(cublas_handle, n, X, incX, Y, incY, &result));`
`163`	`163`	`return result;`
`164`	`164`	`#endif`
`165`	`165`	`}`
`@@ -174,7 +174,7 @@ double BlasConnector::dot( const int n, const double *X, const int incX, const d`
`174`	`174`	`else if (device_type == base_device::AbacusDevice_t::GpuDevice){`
`175`	`175`	`#ifdef __CUDA`
`176`	`176`	`double result = 0.0;`
`177`		`- cublasErrcheck(cublasDdot(cublas_handle, n, X, incx, Y, incy, &result));`
	`177`	`+ cublasErrcheck(cublasDdot(cublas_handle, n, X, incX, Y, incY, &result));`
`178`	`178`	`return result;`
`179`	`179`	`#endif`
`180`	`180`	`}`
`@@ -283,61 +283,61 @@ void BlasConnector::gemm(const char transa, const char transb, const int m, cons`
`283`	`283`	`}`
`284`	`284`
`285`	`285`	`void BlasConnector::gemv(const char trans, const int m, const int n,`
`286`		`- const float alpha, const float* A, const int lda, const float* X, const int incx,`
`287`		`- const float beta, float* Y, const int incy, base_device::AbacusDevice_t device_type)`
	`286`	`+ const float alpha, const float* A, const int lda, const float* X, const int incX,`
	`287`	`+ const float beta, float* Y, const int incY, base_device::AbacusDevice_t device_type)`
`288`	`288`	`{`
`289`	`289`	`if (device_type == base_device::AbacusDevice_t::CpuDevice) {`
`290`		`- sgemv_(&trans, &m, &n, &alpha, A, &lda, X, &incx, &beta, Y, &incy);`
	`290`	`+ sgemv_(&trans, &m, &n, &alpha, A, &lda, X, &incX, &beta, Y, &incY);`
`291`	`291`	`}`
`292`	`292`	`else if (device_type == base_device::AbacusDevice_t::GpuDevice) {`
`293`	`293`	`#ifdef __CUDA`
`294`	`294`	`cublasOperation_t cutrans = judge_trans_op(false, trans, "gemv_op");`
`295`		`- cublasErrcheck(cublasSgemv(cublas_handle, cutrans, m, n, alpha, A, lda, X, incx, beta, Y, incy));`
	`295`	`+ cublasErrcheck(cublasSgemv(cublas_handle, cutrans, m, n, alpha, A, lda, X, incX, beta, Y, incY));`
`296`	`296`	`#endif`
`297`	`297`	`}`
`298`	`298`	`}`
`299`	`299`
`300`	`300`	`void BlasConnector::gemv(const char trans, const int m, const int n,`
`301`		`- const double alpha, const double* A, const int lda, const double* X, const int incx,`
`302`		`- const double beta, double* Y, const int incy, base_device::AbacusDevice_t device_type)`
	`301`	`+ const double alpha, const double* A, const int lda, const double* X, const int incX,`
	`302`	`+ const double beta, double* Y, const int incY, base_device::AbacusDevice_t device_type)`
`303`	`303`	`{`
`304`	`304`	`if (device_type == base_device::AbacusDevice_t::CpuDevice) {`
`305`		`- dgemv_(&trans, &m, &n, &alpha, A, &lda, X, &incx, &beta, Y, &incy);`
	`305`	`+ dgemv_(&trans, &m, &n, &alpha, A, &lda, X, &incX, &beta, Y, &incY);`
`306`	`306`	`}`
`307`	`307`	`else if (device_type == base_device::AbacusDevice_t::GpuDevice) {`
`308`	`308`	`#ifdef __CUDA`
`309`	`309`	`cublasOperation_t cutrans = judge_trans_op(false, trans, "gemv_op");`
`310`		`- cublasErrcheck(cublasDgemv(cublas_handle, cutrans, m, n, alpha, A, lda, X, incx, beta, Y, incy));`
	`310`	`+ cublasErrcheck(cublasDgemv(cublas_handle, cutrans, m, n, alpha, A, lda, X, incX, beta, Y, incY));`
`311`	`311`	`#endif`
`312`	`312`	`}`
`313`	`313`	`}`
`314`	`314`
`315`	`315`	`void BlasConnector::gemv(const char trans, const int m, const int n,`
`316`		`- const std::complex<float> alpha, const std::complex<float> A, const int lda, const std::complex<float> X, const int incx,`
`317`		`- const std::complex<float> beta, std::complex<float> *Y, const int incy, base_device::AbacusDevice_t device_type)`
	`316`	`+ const std::complex<float> alpha, const std::complex<float> A, const int lda, const std::complex<float> X, const int incX,`
	`317`	`+ const std::complex<float> beta, std::complex<float> *Y, const int incY, base_device::AbacusDevice_t device_type)`
`318`	`318`	`{`
`319`	`319`	`if (device_type == base_device::AbacusDevice_t::CpuDevice) {`
`320`		`- cgemv_(&trans, &m, &n, &alpha, A, &lda, X, &incx, &beta, Y, &incy);`
	`320`	`+ cgemv_(&trans, &m, &n, &alpha, A, &lda, X, &incX, &beta, Y, &incY);`
`321`	`321`	`}`
`322`	`322`	`else if (device_type == base_device::AbacusDevice_t::GpuDevice) {`
`323`	`323`	`#ifdef __CUDA`
`324`	`324`	`cublasOperation_t cutrans = judge_trans_op(false, trans, "gemv_op");`
`325`		`- cublasErrcheck(cublasCgemv(cublas_handle, cutrans, m, n, alpha, A, lda, X, incx, beta, Y, incy));`
	`325`	`+ cublasErrcheck(cublasCgemv(cublas_handle, cutrans, m, n, alpha, A, lda, X, incX, beta, Y, incY));`
`326`	`326`	`#endif`
`327`	`327`	`}`
`328`	`328`	`}`
`329`	`329`
`330`	`330`	`void BlasConnector::gemv(const char trans, const int m, const int n,`
`331`		`- const std::complex<double> alpha, const std::complex<double> A, const int lda, const std::complex<double> X, const int incx,`
`332`		`- const std::complex<double> beta, std::complex<double> *Y, const int incy, base_device::AbacusDevice_t device_type)`
	`331`	`+ const std::complex<double> alpha, const std::complex<double> A, const int lda, const std::complex<double> X, const int incX,`
	`332`	`+ const std::complex<double> beta, std::complex<double> *Y, const int incY, base_device::AbacusDevice_t device_type)`
`333`	`333`	`{`
`334`	`334`	`if (device_type == base_device::AbacusDevice_t::CpuDevice) {`
`335`		`- zgemv_(&trans, &m, &n, &alpha, A, &lda, X, &incx, &beta, Y, &incy);`
	`335`	`+ zgemv_(&trans, &m, &n, &alpha, A, &lda, X, &incX, &beta, Y, &incY);`
`336`	`336`	`}`
`337`	`337`	`else if (device_type == base_device::AbacusDevice_t::GpuDevice) {`
`338`	`338`	`#ifdef __CUDA`
`339`	`339`	`cublasOperation_t cutrans = judge_trans_op(false, trans, "gemv_op");`
`340`		`- cublasErrcheck(cublasZgemv(cublas_handle, cutrans, m, n, alpha, A, lda, X, incx, beta, Y, incy));`
	`340`	`+ cublasErrcheck(cublasZgemv(cublas_handle, cutrans, m, n, alpha, A, lda, X, incX, beta, Y, incY));`
`341`	`341`	`#endif`
`342`	`342`	`}`
`343`	`343`	`}`
`@@ -371,16 +371,16 @@ double BlasConnector::nrm2( const int n, const std::complex<double> *X, const in`
`371`	`371`	`}`
`372`	`372`
`373`	`373`	`// copies a into b`
`374`		`-void BlasConnector::copy(const long n, const double a, const int incx, double b, const int incy, base_device::AbacusDevice_t device_type)`
	`374`	`+void BlasConnector::copy(const long n, const double a, const int incX, double b, const int incY, base_device::AbacusDevice_t device_type)`
`375`	`375`	`{`
`376`	`376`	`if (device_type == base_device::AbacusDevice_t::CpuDevice) {`
`377`		`- dcopy_(&n, a, &incx, b, &incy);`
	`377`	`+ dcopy_(&n, a, &incX, b, &incY);`
`378`	`378`	`}`
`379`	`379`	`}`
`380`	`380`
`381`		`-void BlasConnector::copy(const long n, const std::complex<double> a, const int incx, std::complex<double> b, const int incy, base_device::AbacusDevice_t device_type)`
	`381`	`+void BlasConnector::copy(const long n, const std::complex<double> a, const int incX, std::complex<double> b, const int incY, base_device::AbacusDevice_t device_type)`
`382`	`382`	`{`
`383`	`383`	`if (device_type == base_device::AbacusDevice_t::CpuDevice) {`
`384`		`- zcopy_(&n, a, &incx, b, &incy);`
	`384`	`+ zcopy_(&n, a, &incX, b, &incY);`
`385`	`385`	`}`
`386`	`386`	`}`