[pre-commit.ci lite] apply automatic fixes

pre-commit-ci-lite[bot] · web-flow · commit dad1a119c823 · 2024-10-16T10:28:01.000Z
diff --git a/source/module_base/blas_connector.cpp b/source/module_base/blas_connector.cpp
@@ -2,164 +2,186 @@
 
 void BlasConnector::axpy( const int n, const float alpha, const float *X, const int incX, float *Y, const int incY, base_device::AbacusDevice_t device_type)
 {
-	if (device_type == base_device::AbacusDevice_t::CpuDevice)
+	if (device_type == base_device::AbacusDevice_t::CpuDevice) {
 		saxpy_(&n, &alpha, X, &incX, Y, &incY);
 }
+}
 
 void BlasConnector::axpy( const int n, const double alpha, const double *X, const int incX, double *Y, const int incY, base_device::AbacusDevice_t device_type)
 {
-	if (device_type == base_device::AbacusDevice_t::CpuDevice)
+	if (device_type == base_device::AbacusDevice_t::CpuDevice) {
 		daxpy_(&n, &alpha, X, &incX, Y, &incY);
 }
+}
 
 void BlasConnector::axpy( const int n, const std::complex<float> alpha, const std::complex<float> *X, const int incX, std::complex<float> *Y, const int incY, base_device::AbacusDevice_t device_type)
 {
-	if (device_type == base_device::AbacusDevice_t::CpuDevice)
+	if (device_type == base_device::AbacusDevice_t::CpuDevice) {
 		caxpy_(&n, &alpha, X, &incX, Y, &incY);
 }
+}
 
 void BlasConnector::axpy( const int n, const std::complex<double> alpha, const std::complex<double> *X, const int incX, std::complex<double> *Y, const int incY, base_device::AbacusDevice_t device_type)
 {
-	if (device_type == base_device::AbacusDevice_t::CpuDevice)
+	if (device_type == base_device::AbacusDevice_t::CpuDevice) {
 		zaxpy_(&n, &alpha, X, &incX, Y, &incY);
 }
+}
 
 
 // x=a*x
 void BlasConnector::scal( const int n,  const float alpha, float *X, const int incX, base_device::AbacusDevice_t device_type)
 {
-	if (device_type == base_device::AbacusDevice_t::CpuDevice)
+	if (device_type == base_device::AbacusDevice_t::CpuDevice) {
 		sscal_(&n, &alpha, X, &incX);
 }
+}
 
 void BlasConnector::scal( const int n, const double alpha, double *X, const int incX, base_device::AbacusDevice_t device_type)
 {
-	if (device_type == base_device::AbacusDevice_t::CpuDevice)
+	if (device_type == base_device::AbacusDevice_t::CpuDevice) {
 		dscal_(&n, &alpha, X, &incX);
 }
+}
 
 void BlasConnector::scal( const int n, const std::complex<float> alpha, std::complex<float> *X, const int incX, base_device::AbacusDevice_t device_type)
 {
-	if (device_type == base_device::AbacusDevice_t::CpuDevice)
+	if (device_type == base_device::AbacusDevice_t::CpuDevice) {
 		cscal_(&n, &alpha, X, &incX);
 }
+}
 
 void BlasConnector::scal( const int n, const std::complex<double> alpha, std::complex<double> *X, const int incX, base_device::AbacusDevice_t device_type)
 {
-	if (device_type == base_device::AbacusDevice_t::CpuDevice)
+	if (device_type == base_device::AbacusDevice_t::CpuDevice) {
 		zscal_(&n, &alpha, X, &incX);
 }
+}
 
 
 // d=x*y
 float BlasConnector::dot( const int n, const float *X, const int incX, const float *Y, const int incY, base_device::AbacusDevice_t device_type)
 {
-	if (device_type == base_device::AbacusDevice_t::CpuDevice)
+	if (device_type == base_device::AbacusDevice_t::CpuDevice) {
 		return sdot_(&n, X, &incX, Y, &incY);
 }
+}
 
 double BlasConnector::dot( const int n, const double *X, const int incX, const double *Y, const int incY, base_device::AbacusDevice_t device_type)
 {
-	if (device_type == base_device::AbacusDevice_t::CpuDevice)
+	if (device_type == base_device::AbacusDevice_t::CpuDevice) {
 		return ddot_(&n, X, &incX, Y, &incY);
 }
+}
 
 // C = a * A.? * B.? + b * C
 void BlasConnector::gemm(const char transa, const char 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, base_device::AbacusDevice_t device_type)
 {
-	if (device_type == base_device::AbacusDevice_t::CpuDevice)
+	if (device_type == base_device::AbacusDevice_t::CpuDevice) {
 		sgemm_(&transb, &transa, &n, &m, &k,
 		&alpha, b, &ldb, a, &lda,
 		&beta, c, &ldc);
 }
+}
 
 void BlasConnector::gemm(const char transa, const char transb, const int m, const int n, const int k,
 	const double alpha, const double *a, const int lda, const double *b, const int ldb,
 	const double beta, double *c, const int ldc, base_device::AbacusDevice_t device_type)
 {
-	if (device_type == base_device::AbacusDevice_t::CpuDevice)
+	if (device_type == base_device::AbacusDevice_t::CpuDevice) {
 		dgemm_(&transb, &transa, &n, &m, &k,
 		&alpha, b, &ldb, a, &lda,
 		&beta, c, &ldc);
 }
+}
 
 void BlasConnector::gemm(const char transa, const char transb, const int m, const int n, const int k,
     const std::complex<float> alpha, const std::complex<float> *a, const int lda, const std::complex<float> *b, const int ldb,
     const std::complex<float> beta, std::complex<float> *c, const int ldc, base_device::AbacusDevice_t device_type)
 {
-	if (device_type == base_device::AbacusDevice_t::CpuDevice)
+	if (device_type == base_device::AbacusDevice_t::CpuDevice) {
     	cgemm_(&transb, &transa, &n, &m, &k,
         &alpha, b, &ldb, a, &lda,
         &beta, c, &ldc);
 }
+}
 
 void BlasConnector::gemm(const char transa, const char transb, const int m, const int n, const int k,
 	const std::complex<double> alpha, const std::complex<double> *a, const int lda, const std::complex<double> *b, const int ldb,
 	const std::complex<double> beta, std::complex<double> *c, const int ldc, base_device::AbacusDevice_t device_type)
 {
-	if (device_type == base_device::AbacusDevice_t::CpuDevice)
+	if (device_type == base_device::AbacusDevice_t::CpuDevice) {
 		zgemm_(&transb, &transa, &n, &m, &k,
 		&alpha, b, &ldb, a, &lda,
 		&beta, c, &ldc);
 }
+}
 
 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)
 {
-	if (device_type == base_device::AbacusDevice_t::CpuDevice)
+	if (device_type == base_device::AbacusDevice_t::CpuDevice) {
     	dgemv_(&trans, &m, &n, &alpha, A, &lda, X, &incx, &beta, Y, &incy);
 }
+}
 
 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)
 {
-	if (device_type == base_device::AbacusDevice_t::CpuDevice)
+	if (device_type == base_device::AbacusDevice_t::CpuDevice) {
     	cgemv_(&trans, &m, &n, &alpha, A, &lda, X, &incx, &beta, Y, &incy);
 }
+}
 
 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)
 {
-	if (device_type == base_device::AbacusDevice_t::CpuDevice)
+	if (device_type == base_device::AbacusDevice_t::CpuDevice) {
     	zgemv_(&trans, &m, &n, &alpha, A, &lda, X, &incx, &beta, Y, &incy);
 }
+}
 
 
 // out = ||x||_2
 float BlasConnector::nrm2( const int n, const float *X, const int incX, base_device::AbacusDevice_t device_type )
 {
-	if (device_type == base_device::AbacusDevice_t::CpuDevice)
+	if (device_type == base_device::AbacusDevice_t::CpuDevice) {
 		return snrm2_( &n, X, &incX );
 }
+}
 
 
 double BlasConnector::nrm2( const int n, const double *X, const int incX, base_device::AbacusDevice_t device_type )
 {
-	if (device_type == base_device::AbacusDevice_t::CpuDevice)
+	if (device_type == base_device::AbacusDevice_t::CpuDevice) {
 		return dnrm2_( &n, X, &incX );
 }
+}
 
 
 double BlasConnector::nrm2( const int n, const std::complex<double> *X, const int incX, base_device::AbacusDevice_t device_type )
 {
-	if (device_type == base_device::AbacusDevice_t::CpuDevice)
+	if (device_type == base_device::AbacusDevice_t::CpuDevice) {
 		return dznrm2_( &n, X, &incX );
 }
+}
 
 // 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)
 {
-	if (device_type == base_device::AbacusDevice_t::CpuDevice)
+	if (device_type == base_device::AbacusDevice_t::CpuDevice) {
 		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)
 {
-	if (device_type == base_device::AbacusDevice_t::CpuDevice)
+	if (device_type == base_device::AbacusDevice_t::CpuDevice) {
 		zcopy_(&n, a, &incx, b, &incy);
+}
 }

Original file line number	Diff line number	Diff line change
`@@ -2,164 +2,186 @@`
`2`	`2`
`3`	`3`	`void BlasConnector::axpy( const int n, const float alpha, const float X, const int incX, float Y, const int incY, base_device::AbacusDevice_t device_type)`
`4`	`4`	`{`
`5`		`- if (device_type == base_device::AbacusDevice_t::CpuDevice)`
	`5`	`+ if (device_type == base_device::AbacusDevice_t::CpuDevice) {`
`6`	`6`	`saxpy_(&n, &alpha, X, &incX, Y, &incY);`
`7`	`7`	`}`
	`8`	`+}`
`8`	`9`
`9`	`10`	`void BlasConnector::axpy( const int n, const double alpha, const double X, const int incX, double Y, const int incY, base_device::AbacusDevice_t device_type)`
`10`	`11`	`{`
`11`		`- if (device_type == base_device::AbacusDevice_t::CpuDevice)`
	`12`	`+ if (device_type == base_device::AbacusDevice_t::CpuDevice) {`
`12`	`13`	`daxpy_(&n, &alpha, X, &incX, Y, &incY);`
`13`	`14`	`}`
	`15`	`+}`
`14`	`16`
`15`	`17`	`void BlasConnector::axpy( const int n, const std::complex<float> alpha, const std::complex<float> X, const int incX, std::complex<float> Y, const int incY, base_device::AbacusDevice_t device_type)`
`16`	`18`	`{`
`17`		`- if (device_type == base_device::AbacusDevice_t::CpuDevice)`
	`19`	`+ if (device_type == base_device::AbacusDevice_t::CpuDevice) {`
`18`	`20`	`caxpy_(&n, &alpha, X, &incX, Y, &incY);`
`19`	`21`	`}`
	`22`	`+}`
`20`	`23`
`21`	`24`	`void BlasConnector::axpy( const int n, const std::complex<double> alpha, const std::complex<double> X, const int incX, std::complex<double> Y, const int incY, base_device::AbacusDevice_t device_type)`
`22`	`25`	`{`
`23`		`- if (device_type == base_device::AbacusDevice_t::CpuDevice)`
	`26`	`+ if (device_type == base_device::AbacusDevice_t::CpuDevice) {`
`24`	`27`	`zaxpy_(&n, &alpha, X, &incX, Y, &incY);`
`25`	`28`	`}`
	`29`	`+}`
`26`	`30`
`27`	`31`
`28`	`32`	`// x=a*x`
`29`	`33`	`void BlasConnector::scal( const int n, const float alpha, float *X, const int incX, base_device::AbacusDevice_t device_type)`
`30`	`34`	`{`
`31`		`- if (device_type == base_device::AbacusDevice_t::CpuDevice)`
	`35`	`+ if (device_type == base_device::AbacusDevice_t::CpuDevice) {`
`32`	`36`	`sscal_(&n, &alpha, X, &incX);`
`33`	`37`	`}`
	`38`	`+}`
`34`	`39`
`35`	`40`	`void BlasConnector::scal( const int n, const double alpha, double *X, const int incX, base_device::AbacusDevice_t device_type)`
`36`	`41`	`{`
`37`		`- if (device_type == base_device::AbacusDevice_t::CpuDevice)`
	`42`	`+ if (device_type == base_device::AbacusDevice_t::CpuDevice) {`
`38`	`43`	`dscal_(&n, &alpha, X, &incX);`
`39`	`44`	`}`
	`45`	`+}`
`40`	`46`
`41`	`47`	`void BlasConnector::scal( const int n, const std::complex<float> alpha, std::complex<float> *X, const int incX, base_device::AbacusDevice_t device_type)`
`42`	`48`	`{`
`43`		`- if (device_type == base_device::AbacusDevice_t::CpuDevice)`
	`49`	`+ if (device_type == base_device::AbacusDevice_t::CpuDevice) {`
`44`	`50`	`cscal_(&n, &alpha, X, &incX);`
`45`	`51`	`}`
	`52`	`+}`
`46`	`53`
`47`	`54`	`void BlasConnector::scal( const int n, const std::complex<double> alpha, std::complex<double> *X, const int incX, base_device::AbacusDevice_t device_type)`
`48`	`55`	`{`
`49`		`- if (device_type == base_device::AbacusDevice_t::CpuDevice)`
	`56`	`+ if (device_type == base_device::AbacusDevice_t::CpuDevice) {`
`50`	`57`	`zscal_(&n, &alpha, X, &incX);`
`51`	`58`	`}`
	`59`	`+}`
`52`	`60`
`53`	`61`
`54`	`62`	`// d=x*y`
`55`	`63`	`float BlasConnector::dot( const int n, const float X, const int incX, const float Y, const int incY, base_device::AbacusDevice_t device_type)`
`56`	`64`	`{`
`57`		`- if (device_type == base_device::AbacusDevice_t::CpuDevice)`
	`65`	`+ if (device_type == base_device::AbacusDevice_t::CpuDevice) {`
`58`	`66`	`return sdot_(&n, X, &incX, Y, &incY);`
`59`	`67`	`}`
	`68`	`+}`
`60`	`69`
`61`	`70`	`double BlasConnector::dot( const int n, const double X, const int incX, const double Y, const int incY, base_device::AbacusDevice_t device_type)`
`62`	`71`	`{`
`63`		`- if (device_type == base_device::AbacusDevice_t::CpuDevice)`
	`72`	`+ if (device_type == base_device::AbacusDevice_t::CpuDevice) {`
`64`	`73`	`return ddot_(&n, X, &incX, Y, &incY);`
`65`	`74`	`}`
	`75`	`+}`
`66`	`76`
`67`	`77`	`// C = a * A.? * B.? + b * C`
`68`	`78`	`void BlasConnector::gemm(const char transa, const char transb, const int m, const int n, const int k,`
`69`	`79`	`const float alpha, const float a, const int lda, const float b, const int ldb,`
`70`	`80`	`const float beta, float *c, const int ldc, base_device::AbacusDevice_t device_type)`
`71`	`81`	`{`
`72`		`- if (device_type == base_device::AbacusDevice_t::CpuDevice)`
	`82`	`+ if (device_type == base_device::AbacusDevice_t::CpuDevice) {`
`73`	`83`	`sgemm_(&transb, &transa, &n, &m, &k,`
`74`	`84`	`&alpha, b, &ldb, a, &lda,`
`75`	`85`	`&beta, c, &ldc);`
`76`	`86`	`}`
	`87`	`+}`
`77`	`88`
`78`	`89`	`void BlasConnector::gemm(const char transa, const char transb, const int m, const int n, const int k,`
`79`	`90`	`const double alpha, const double a, const int lda, const double b, const int ldb,`
`80`	`91`	`const double beta, double *c, const int ldc, base_device::AbacusDevice_t device_type)`
`81`	`92`	`{`
`82`		`- if (device_type == base_device::AbacusDevice_t::CpuDevice)`
	`93`	`+ if (device_type == base_device::AbacusDevice_t::CpuDevice) {`
`83`	`94`	`dgemm_(&transb, &transa, &n, &m, &k,`
`84`	`95`	`&alpha, b, &ldb, a, &lda,`
`85`	`96`	`&beta, c, &ldc);`
`86`	`97`	`}`
	`98`	`+}`
`87`	`99`
`88`	`100`	`void BlasConnector::gemm(const char transa, const char transb, const int m, const int n, const int k,`
`89`	`101`	`const std::complex<float> alpha, const std::complex<float> a, const int lda, const std::complex<float> b, const int ldb,`
`90`	`102`	`const std::complex<float> beta, std::complex<float> *c, const int ldc, base_device::AbacusDevice_t device_type)`
`91`	`103`	`{`
`92`		`- if (device_type == base_device::AbacusDevice_t::CpuDevice)`
	`104`	`+ if (device_type == base_device::AbacusDevice_t::CpuDevice) {`
`93`	`105`	`cgemm_(&transb, &transa, &n, &m, &k,`
`94`	`106`	`&alpha, b, &ldb, a, &lda,`
`95`	`107`	`&beta, c, &ldc);`
`96`	`108`	`}`
	`109`	`+}`
`97`	`110`
`98`	`111`	`void BlasConnector::gemm(const char transa, const char transb, const int m, const int n, const int k,`
`99`	`112`	`const std::complex<double> alpha, const std::complex<double> a, const int lda, const std::complex<double> b, const int ldb,`
`100`	`113`	`const std::complex<double> beta, std::complex<double> *c, const int ldc, base_device::AbacusDevice_t device_type)`
`101`	`114`	`{`
`102`		`- if (device_type == base_device::AbacusDevice_t::CpuDevice)`
	`115`	`+ if (device_type == base_device::AbacusDevice_t::CpuDevice) {`
`103`	`116`	`zgemm_(&transb, &transa, &n, &m, &k,`
`104`	`117`	`&alpha, b, &ldb, a, &lda,`
`105`	`118`	`&beta, c, &ldc);`
`106`	`119`	`}`
	`120`	`+}`
`107`	`121`
`108`	`122`	`void BlasConnector::gemv(const char trans, const int m, const int n,`
`109`	`123`	`const double alpha, const double* A, const int lda, const double* X, const int incx,`
`110`	`124`	`const double beta, double* Y, const int incy, base_device::AbacusDevice_t device_type)`
`111`	`125`	`{`
`112`		`- if (device_type == base_device::AbacusDevice_t::CpuDevice)`
	`126`	`+ if (device_type == base_device::AbacusDevice_t::CpuDevice) {`
`113`	`127`	`dgemv_(&trans, &m, &n, &alpha, A, &lda, X, &incx, &beta, Y, &incy);`
`114`	`128`	`}`
	`129`	`+}`
`115`	`130`
`116`	`131`	`void BlasConnector::gemv(const char trans, const int m, const int n,`
`117`	`132`	`const std::complex<float> alpha, const std::complex<float> A, const int lda, const std::complex<float> X, const int incx,`
`118`	`133`	`const std::complex<float> beta, std::complex<float> *Y, const int incy, base_device::AbacusDevice_t device_type)`
`119`	`134`	`{`
`120`		`- if (device_type == base_device::AbacusDevice_t::CpuDevice)`
	`135`	`+ if (device_type == base_device::AbacusDevice_t::CpuDevice) {`
`121`	`136`	`cgemv_(&trans, &m, &n, &alpha, A, &lda, X, &incx, &beta, Y, &incy);`
`122`	`137`	`}`
	`138`	`+}`
`123`	`139`
`124`	`140`	`void BlasConnector::gemv(const char trans, const int m, const int n,`
`125`	`141`	`const std::complex<double> alpha, const std::complex<double> A, const int lda, const std::complex<double> X, const int incx,`
`126`	`142`	`const std::complex<double> beta, std::complex<double> *Y, const int incy, base_device::AbacusDevice_t device_type)`
`127`	`143`	`{`
`128`		`- if (device_type == base_device::AbacusDevice_t::CpuDevice)`
	`144`	`+ if (device_type == base_device::AbacusDevice_t::CpuDevice) {`
`129`	`145`	`zgemv_(&trans, &m, &n, &alpha, A, &lda, X, &incx, &beta, Y, &incy);`
`130`	`146`	`}`
	`147`	`+}`
`131`	`148`
`132`	`149`
`133`	`150`	`// out = \|\|x\|\|_2`
`134`	`151`	`float BlasConnector::nrm2( const int n, const float *X, const int incX, base_device::AbacusDevice_t device_type )`
`135`	`152`	`{`
`136`		`- if (device_type == base_device::AbacusDevice_t::CpuDevice)`
	`153`	`+ if (device_type == base_device::AbacusDevice_t::CpuDevice) {`
`137`	`154`	`return snrm2_( &n, X, &incX );`
`138`	`155`	`}`
	`156`	`+}`
`139`	`157`
`140`	`158`
`141`	`159`	`double BlasConnector::nrm2( const int n, const double *X, const int incX, base_device::AbacusDevice_t device_type )`
`142`	`160`	`{`
`143`		`- if (device_type == base_device::AbacusDevice_t::CpuDevice)`
	`161`	`+ if (device_type == base_device::AbacusDevice_t::CpuDevice) {`
`144`	`162`	`return dnrm2_( &n, X, &incX );`
`145`	`163`	`}`
	`164`	`+}`
`146`	`165`
`147`	`166`
`148`	`167`	`double BlasConnector::nrm2( const int n, const std::complex<double> *X, const int incX, base_device::AbacusDevice_t device_type )`
`149`	`168`	`{`
`150`		`- if (device_type == base_device::AbacusDevice_t::CpuDevice)`
	`169`	`+ if (device_type == base_device::AbacusDevice_t::CpuDevice) {`
`151`	`170`	`return dznrm2_( &n, X, &incX );`
`152`	`171`	`}`
	`172`	`+}`
`153`	`173`
`154`	`174`	`// copies a into b`
`155`	`175`	`void BlasConnector::copy(const long n, const double a, const int incx, double b, const int incy, base_device::AbacusDevice_t device_type)`
`156`	`176`	`{`
`157`		`- if (device_type == base_device::AbacusDevice_t::CpuDevice)`
	`177`	`+ if (device_type == base_device::AbacusDevice_t::CpuDevice) {`
`158`	`178`	`dcopy_(&n, a, &incx, b, &incy);`
`159`	`179`	`}`
	`180`	`+}`
`160`	`181`
`161`	`182`	`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)`
`162`	`183`	`{`
`163`		`- if (device_type == base_device::AbacusDevice_t::CpuDevice)`
	`184`	`+ if (device_type == base_device::AbacusDevice_t::CpuDevice) {`
`164`	`185`	`zcopy_(&n, a, &incx, b, &incy);`
	`186`	`+}`
`165`	`187`	`}`