DFT-EFE
 
Loading...
Searching...
No Matches
BlasLapack.h
Go to the documentation of this file.
1/******************************************************************************
2 * Copyright (c) 2021. *
3 * The Regents of the University of Michigan and DFT-EFE developers. *
4 * *
5 * This file is part of the DFT-EFE code. *
6 * *
7 * DFT-EFE is free software: you can redistribute it and/or modify *
8 * it under the terms of the Lesser GNU General Public License as *
9 * published by the Free Software Foundation, either version 3 of *
10 * the License, or (at your option) any later version. *
11 * *
12 * DFT-EFE is distributed in the hope that it will be useful, but *
13 * WITHOUT ANY WARRANTY; without even the implied warranty *
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. *
15 * See the Lesser GNU General Public License for more details. *
16 * *
17 * You should have received a copy of the GNU Lesser General Public *
18 * License at the top level of DFT-EFE distribution. If not, see *
19 * <https://www.gnu.org/licenses/>. *
20 ******************************************************************************/
21
22/*
23 * @author Vishal Subramanian, Avirup Sircar
24 */
25
26#ifndef dftefeBlasWrappers_h
27#define dftefeBlasWrappers_h
28
29#include <linearAlgebra/LinearAlgebraTypes.h>
30#include <linearAlgebra/BlasLapackTypedef.h>
31#include <linearAlgebra/LinAlgOpContext.h>
32#include <utils/TypeConfig.h>
33
34namespace dftefe
35{
36 namespace linearAlgebra
37 {
38 namespace blasLapack
39 {
40 template <typename ValueType,
41 typename dftefe::utils::MemorySpace memorySpace>
42 real_type<ValueType>
43 asum(size_type n,
44 ValueType const * x,
45 size_type incx,
46 LinAlgOpContext<memorySpace> &context);
47
48 template <typename ValueType,
49 typename dftefe::utils::MemorySpace memorySpace>
50 real_type<ValueType>
51 amax(size_type n,
52 ValueType const * x,
53 size_type incx,
54 LinAlgOpContext<memorySpace> &context);
55
65 template <typename ValueType,
66 typename dftefe::utils::MemorySpace memorySpace>
67 std::vector<double>
68 amaxsMultiVector(size_type vecSize,
69 size_type numVec,
70 ValueType const * multiVecData,
71 LinAlgOpContext<memorySpace> &context);
72
73
74 template <typename ValueType1,
75 typename ValueType2,
76 typename dftefe::utils::MemorySpace memorySpace>
77 void
78 axpy(size_type n,
79 scalar_type<ValueType1, ValueType2> alpha,
80 ValueType1 const * x,
81 size_type incx,
82 ValueType2 * y,
83 size_type incy,
84 LinAlgOpContext<memorySpace> & context);
85
86 // i have neglected incx & incy parameters
98 template <typename ValueType1,
99 typename ValueType2,
100 typename dftefe::utils::MemorySpace memorySpace>
101 void
102 reciprocalX(size_type n,
103 const ValueType1 alpha,
104 ValueType2 const * x,
105 scalar_type<ValueType1, ValueType2> *y,
106 LinAlgOpContext<memorySpace> & context);
107
108
116 template <typename ValueType1,
117 typename ValueType2,
118 typename dftefe::utils::MemorySpace memorySpace>
119 void
120 ascale(size_type n,
121 ValueType1 alpha,
122 const ValueType2 * x,
123 scalar_type<ValueType1, ValueType2> *z,
124 LinAlgOpContext<memorySpace> & context);
125
126
134 template <typename ValueType1,
135 typename ValueType2,
136 typename dftefe::utils::MemorySpace memorySpace>
137 void
138 hadamardProduct(size_type n,
139 const ValueType1 * x,
140 const ValueType2 * y,
141 scalar_type<ValueType1, ValueType2> *z,
142 LinAlgOpContext<memorySpace> & context);
143
144 // /*
145 // * @brief Template for performing \f$ blockedOutput_ij = blockedInput_ij * singleVectorInput_i$
146 // * @param[in] size size of the blocked Input array
147 // * @param[in] numComponets no of componets
148 // * @param[in] blockedInput blocked array
149 // * @param[in] singleVectorInput array
150 // * @param[out] blockedOutput blocked array
151 // */
152 // template <typename ValueType1,
153 // typename ValueType2,
154 // typename dftefe::utils::MemorySpace memorySpace>
155 // void
156 // blockedHadamardProduct(const size_type n,
157 // const size_type blockSize,
158 // const ValueType1 * blockedInput,
159 // const ValueType2 * singleVectorInput,
160 // scalar_type<ValueType1, ValueType2> *blockedOutput,
161 // LinAlgOpContext<memorySpace> & context);
162
163
179 template <typename ValueType1,
180 typename ValueType2,
181 typename dftefe::utils::MemorySpace memorySpace>
182 void
183 hadamardProduct(size_type n,
184 const ValueType1 * x,
185 const ValueType2 * y,
186 const ScalarOp & opx,
187 const ScalarOp & opy,
188 scalar_type<ValueType1, ValueType2> *z,
189 LinAlgOpContext<memorySpace> & context);
190
216 template <typename ValueType1,
217 typename ValueType2,
218 dftefe::utils::MemorySpace memorySpace>
219 void
220 scaleStridedVarBatched(const size_type numMats,
221 const ScalarOp * scalarOpA,
222 const ScalarOp * scalarOpB,
223 const size_type * stridea,
224 const size_type * strideb,
225 const size_type * stridec,
226 const size_type * m,
227 const size_type * n,
228 const size_type * k,
229 const ValueType1 * dA,
230 const ValueType2 * dB,
231 scalar_type<ValueType1, ValueType2> *dC,
232 LinAlgOpContext<memorySpace> & context);
233
256 template <typename ValueType1,
257 typename ValueType2,
258 typename dftefe::utils::MemorySpace memorySpace>
259 void
260 khatriRaoProduct(const Layout layout,
261 size_type sizeI,
262 size_type sizeJ,
263 size_type sizeK,
264 const ValueType1 * A,
265 const ValueType2 * B,
266 scalar_type<ValueType1, ValueType2> *Z,
267 LinAlgOpContext<memorySpace> & context);
268
269
292 template <typename ValueType1,
293 typename ValueType2,
294 typename dftefe::utils::MemorySpace memorySpace>
295 void
296 transposedKhatriRaoProduct(const Layout layout,
297 size_type sizeI,
298 size_type sizeJ,
299 size_type sizeK,
300 const ValueType1 * A,
301 const ValueType2 * B,
302 scalar_type<ValueType1, ValueType2> *Z,
303 LinAlgOpContext<memorySpace> & context);
304
305
315 template <typename ValueType1,
316 typename ValueType2,
317 typename dftefe::utils::MemorySpace memorySpace>
318 void
319 axpby(size_type n,
320 scalar_type<ValueType1, ValueType2> alpha,
321 ValueType1 const * x,
322 scalar_type<ValueType1, ValueType2> beta,
323 const ValueType2 * y,
324 scalar_type<ValueType1, ValueType2> *z,
325 LinAlgOpContext<memorySpace> & context);
326
336 template <typename ValueType1,
337 typename ValueType2,
338 typename dftefe::utils::MemorySpace memorySpace>
339 void
340 axpbyBlocked(const size_type n,
341 const size_type blockSize,
342 const scalar_type<ValueType1, ValueType2> *alpha,
343 const ValueType1 * x,
344 const scalar_type<ValueType1, ValueType2> *beta,
345 const ValueType2 * y,
346 scalar_type<ValueType1, ValueType2> * z,
347 LinAlgOpContext<memorySpace> & context);
348
349
350 template <typename ValueType1,
351 typename ValueType2,
352 typename dftefe::utils::MemorySpace memorySpace>
353 scalar_type<ValueType1, ValueType2>
354 dot(size_type n,
355 ValueType1 const * x,
356 size_type incx,
357 ValueType2 const * y,
358 size_type incy,
359 LinAlgOpContext<memorySpace> &context);
360
361
379 template <typename ValueType1,
380 typename ValueType2,
381 typename dftefe::utils::MemorySpace memorySpace>
382 void
383 dotMultiVector(size_type vecSize,
384 size_type numVec,
385 const ValueType1 * multiVecDataX,
386 const ValueType2 * multiVecDataY,
387 const ScalarOp & opX,
388 const ScalarOp & opY,
389 scalar_type<ValueType1, ValueType2> *multiVecDotProduct,
390 LinAlgOpContext<memorySpace> & context);
391
392
393 template <typename ValueType,
394 typename dftefe::utils::MemorySpace memorySpace>
395 real_type<ValueType>
396 nrm2(size_type n,
397 ValueType const * x,
398 size_type incx,
399 LinAlgOpContext<memorySpace> &context);
400
410 template <typename ValueType,
411 typename dftefe::utils::MemorySpace memorySpace>
412 std::vector<double>
413 nrms2MultiVector(size_type vecSize,
414 size_type numVec,
415 ValueType const * multiVecData,
416 LinAlgOpContext<memorySpace> &context);
417
418 template <typename ValueType1,
419 typename ValueType2,
420 typename dftefe::utils::MemorySpace memorySpace>
421 void
422 gemm(Layout layout,
423 Op transA,
424 Op transB,
425 size_type m,
426 size_type n,
427 size_type k,
428 scalar_type<ValueType1, ValueType2> alpha,
429 ValueType1 const * dA,
430 size_type ldda,
431 ValueType2 const * dB,
432 size_type lddb,
433 scalar_type<ValueType1, ValueType2> beta,
434 scalar_type<ValueType1, ValueType2> *dC,
435 size_type lddc,
436 LinAlgOpContext<memorySpace> & context);
437
444 template <typename ValueType1,
445 typename ValueType2,
446 typename dftefe::utils::MemorySpace memorySpace>
447 void
448 gemmStridedVarBatched(Layout layout,
449 size_type numMats,
450 const Op * transA,
451 const Op * transB,
452 const size_type * stridea,
453 const size_type * strideb,
454 const size_type * stridec,
455 const size_type * m,
456 const size_type * n,
457 const size_type * k,
458 scalar_type<ValueType1, ValueType2> alpha,
459 const ValueType1 * dA,
460 const size_type * ldda,
461 const ValueType2 * dB,
462 const size_type * lddb,
463 scalar_type<ValueType1, ValueType2> beta,
464 scalar_type<ValueType1, ValueType2> *dC,
465 const size_type * lddc,
466 LinAlgOpContext<memorySpace> & context);
467
468
472 template <typename ValueType,
473 typename dftefe::utils::MemorySpace memorySpace>
474 LapackError
475 inverse(size_type n, ValueType *A, LinAlgOpContext<memorySpace> &context);
476
480 template <typename ValueType,
481 typename dftefe::utils::MemorySpace memorySpace>
482 LapackError
483 trtri(Uplo uplo,
484 Diag diag,
485 size_type n,
486 ValueType * A,
487 size_type lda,
488 LinAlgOpContext<memorySpace> &context);
489
493 template <typename ValueType,
494 typename dftefe::utils::MemorySpace memorySpace>
495 LapackError
496 potrf(Uplo uplo,
497 size_type n,
498 ValueType * A,
499 size_type lda,
500 LinAlgOpContext<memorySpace> &context);
501
505 template <typename ValueType,
506 typename dftefe::utils::MemorySpace memorySpace>
507 LapackError
508 steqr(Job jobz,
509 size_type n,
510 real_type<ValueType> * D,
511 real_type<ValueType> * E,
512 ValueType * Z,
513 size_type ldz,
514 LinAlgOpContext<memorySpace> &context);
515
519 template <typename ValueType,
520 typename dftefe::utils::MemorySpace memorySpace>
521 LapackError
522 heevd(Job jobz,
523 Uplo uplo,
524 size_type n,
525 ValueType * A,
526 size_type lda,
527 real_type<ValueType> * W,
528 LinAlgOpContext<memorySpace> &context);
529
533 template <typename ValueType,
534 typename dftefe::utils::MemorySpace memorySpace>
535 LapackError
536 hegv(size_type itype,
537 Job jobz,
538 Uplo uplo,
539 size_type n,
540 ValueType * A,
541 size_type lda,
542 ValueType * B,
543 size_type ldb,
544 real_type<ValueType> * W,
545 LinAlgOpContext<memorySpace> &context);
546
551 template <typename ValueType,
552 typename dftefe::utils::MemorySpace memorySpace>
553 LapackError
554 gesv(size_type n,
555 size_type nrhs,
556 ValueType * A,
557 size_type lda,
558 LapackInt * ipiv,
559 ValueType * B,
560 size_type ldb,
561 LinAlgOpContext<memorySpace> &context);
562
563 } // namespace blasLapack
564 } // namespace linearAlgebra
565} // namespace dftefe
566
567#include "BlasLapack.t.cpp"
568#endif // dftefeBlasWrappers_h
dftefe::linearAlgebra::LinAlgOpContext
Definition: LinAlgOpContext.h:38
dftefe::linearAlgebra::blasLapack::transposedKhatriRaoProduct
void transposedKhatriRaoProduct(const Layout layout, const size_type sizeI, const size_type sizeJ, const size_type sizeK, const ValueType1 *A, const ValueType2 *B, scalar_type< ValueType1, ValueType2 > *Z, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:213
dftefe::linearAlgebra::blasLapack::amax
real_type< ValueType > amax(size_type n, ValueType const *x, size_type incx, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:31
dftefe::linearAlgebra::blasLapack::Diag
blas::Diag Diag
Definition: BlasLapackTypedef.h:44
dftefe::linearAlgebra::blasLapack::gemmStridedVarBatched
void gemmStridedVarBatched(const Layout layout, const size_type numMats, const Op *transA, const Op *transB, const size_type *stridea, const size_type *strideb, const size_type *stridec, const size_type *m, const size_type *n, const size_type *k, const scalar_type< ValueType1, ValueType2 > alpha, const ValueType1 *dA, const size_type *ldda, const ValueType2 *dB, const size_type *lddb, const scalar_type< ValueType1, ValueType2 > beta, scalar_type< ValueType1, ValueType2 > *dC, const size_type *lddc, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:411
dftefe::linearAlgebra::blasLapack::dotMultiVector
void dotMultiVector(const size_type vecSize, const size_type numVec, const ValueType1 *multiVecDataX, const ValueType2 *multiVecDataY, const ScalarOp &opX, const ScalarOp &opY, scalar_type< ValueType1, ValueType2 > *multiVecDotProduct, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:285
dftefe::linearAlgebra::blasLapack::gesv
LapackError gesv(size_type n, size_type nrhs, ValueType *A, size_type lda, LapackInt *ipiv, ValueType *B, size_type ldb, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:678
dftefe::linearAlgebra::blasLapack::hadamardProduct
void hadamardProduct(size_type n, const ValueType1 *x, const ValueType2 *y, scalar_type< ValueType1, ValueType2 > *z, LinAlgOpContext< memorySpace > &context)
Template for performing alpha z_i = x_i * y_i$.
Definition: BlasLapack.t.cpp:113
dftefe::linearAlgebra::blasLapack::axpy
void axpy(size_type n, scalar_type< ValueType1, ValueType2 > alpha, ValueType1 const *x, size_type incx, ValueType2 *y, size_type incy, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:65
dftefe::linearAlgebra::blasLapack::Uplo
blas::Uplo Uplo
Definition: BlasLapackTypedef.h:45
dftefe::linearAlgebra::blasLapack::Layout
blas::Layout Layout
Definition: BlasLapackTypedef.h:46
dftefe::linearAlgebra::blasLapack::amaxsMultiVector
std::vector< double > amaxsMultiVector(size_type vecSize, size_type numVec, ValueType const *multiVecData, LinAlgOpContext< memorySpace > &context)
Template for computing norms of all the numVec vectors in a multi Vector.
Definition: BlasLapack.t.cpp:47
dftefe::linearAlgebra::blasLapack::khatriRaoProduct
void khatriRaoProduct(const Layout layout, const size_type sizeI, const size_type sizeJ, const size_type sizeK, const ValueType1 *A, const ValueType2 *B, scalar_type< ValueType1, ValueType2 > *Z, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:196
dftefe::linearAlgebra::blasLapack::Op
blas::Op Op
Definition: BlasLapackTypedef.h:43
dftefe::linearAlgebra::blasLapack::steqr
LapackError steqr(Job jobz, size_type n, real_type< ValueType > *D, real_type< ValueType > *E, ValueType *Z, size_type ldz, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:591
dftefe::linearAlgebra::blasLapack::LapackInt
int64_t LapackInt
Definition: BlasLapackTypedef.h:53
dftefe::linearAlgebra::blasLapack::nrm2
real_type< ValueType > nrm2(const size_type n, ValueType const *x, const size_type incx, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:308
dftefe::linearAlgebra::blasLapack::potrf
LapackError potrf(Uplo uplo, size_type n, ValueType *A, size_type lda, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:565
dftefe::linearAlgebra::blasLapack::axpbyBlocked
void axpbyBlocked(const size_type n, const size_type blockSize, const scalar_type< ValueType1, ValueType2 > *alpha, const ValueType1 *x, const scalar_type< ValueType1, ValueType2 > *beta, const ValueType2 *y, scalar_type< ValueType1, ValueType2 > *z, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:247
dftefe::linearAlgebra::blasLapack::scalar_type
blas::scalar_type< ValueType1, ValueType2 > scalar_type
Definition: BlasLapackTypedef.h:70
dftefe::linearAlgebra::blasLapack::nrms2MultiVector
std::vector< double > nrms2MultiVector(const size_type vecSize, const size_type numVec, const ValueType *multiVecData, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:324
dftefe::linearAlgebra::blasLapack::hegv
LapackError hegv(size_type itype, Job jobz, Uplo uplo, size_type n, ValueType *A, size_type lda, ValueType *B, size_type ldb, real_type< ValueType > *W, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:647
dftefe::linearAlgebra::blasLapack::asum
real_type< ValueType > asum(size_type n, ValueType const *x, size_type incx, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:15
dftefe::linearAlgebra::blasLapack::real_type
blas::real_type< ValueType > real_type
Definition: BlasLapackTypedef.h:64
dftefe::linearAlgebra::blasLapack::axpby
void axpby(const size_type n, const scalar_type< ValueType1, ValueType2 > alpha, const ValueType1 *x, const scalar_type< ValueType1, ValueType2 > beta, const ValueType2 *y, scalar_type< ValueType1, ValueType2 > *z, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:231
dftefe::linearAlgebra::blasLapack::gemm
void gemm(const Layout layout, const Op transA, const Op transB, const size_type m, const size_type n, const size_type k, const scalar_type< ValueType1, ValueType2 > alpha, ValueType1 const *dA, const size_type ldda, ValueType2 const *dB, const size_type lddb, const scalar_type< ValueType1, ValueType2 > beta, scalar_type< ValueType1, ValueType2 > *dC, const size_type lddc, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:338
dftefe::linearAlgebra::blasLapack::dot
scalar_type< ValueType1, ValueType2 > dot(const size_type n, ValueType1 const *x, const size_type incx, ValueType2 const *y, const size_type incy, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:265
dftefe::linearAlgebra::blasLapack::trtri
LapackError trtri(Uplo uplo, Diag diag, size_type n, ValueType *A, size_type lda, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:538
dftefe::linearAlgebra::blasLapack::reciprocalX
void reciprocalX(size_type n, const ValueType1 alpha, ValueType2 const *x, scalar_type< ValueType1, ValueType2 > *y, LinAlgOpContext< memorySpace > &context)
Template for computing the multiplicative inverse of all the elements of x, does not check if any ele...
Definition: BlasLapack.t.cpp:83
dftefe::linearAlgebra::blasLapack::ScalarOp
ScalarOp
Definition: BlasLapackTypedef.h:56
dftefe::linearAlgebra::blasLapack::scaleStridedVarBatched
void scaleStridedVarBatched(const size_type numMats, const ScalarOp *scalarOpA, const ScalarOp *scalarOpB, const size_type *stridea, const size_type *strideb, const size_type *stridec, const size_type *m, const size_type *n, const size_type *k, const ValueType1 *dA, const ValueType2 *dB, scalar_type< ValueType1, ValueType2 > *dC, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:162
dftefe::linearAlgebra::blasLapack::heevd
LapackError heevd(Job jobz, Uplo uplo, size_type n, ValueType *A, size_type lda, real_type< ValueType > *W, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:619
dftefe::linearAlgebra::blasLapack::Job
lapack::Job Job
Definition: BlasLapackTypedef.h:49
dftefe::linearAlgebra::blasLapack::inverse
LapackError inverse(size_type n, ValueType *A, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:512
dftefe::linearAlgebra::blasLapack::ascale
void ascale(const size_type n, const ValueType1 alpha, const ValueType2 *x, scalar_type< ValueType1, ValueType2 > *z, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:97
dftefe::utils::MemorySpace
MemorySpace
Definition: MemorySpaceType.h:37
dftefe
dealii includes
Definition: AtomFieldDataSpherical.cpp:31
dftefe::size_type
unsigned int size_type
Definition: TypeConfig.h:8
dftefe::linearAlgebra::LapackError
Definition: LinearAlgebraTypes.h:113