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 <utils/ConditionalOStream.h>
31#include <utils/Profiler.h>
32#include "Defaults.h"
33#include <linearAlgebra/BlasAPIWrapper.h>
34
35namespace dftefe
36{
37 namespace linearAlgebra
38 {
39 namespace blasLapack
40 {
41 template <typename ValueType,
42 typename dftefe::utils::MemorySpace memorySpace>
43 real_type<ValueType>
44 asum(size_type n,
45 ValueType const * x,
46 size_type incx,
47 LinAlgOpContext<memorySpace> &context);
48
49 template <typename ValueType,
50 typename dftefe::utils::MemorySpace memorySpace>
51 real_type<ValueType>
52 amax(size_type n,
53 ValueType const * x,
54 size_type incx,
55 LinAlgOpContext<memorySpace> &context);
56
66 template <typename ValueType,
67 typename dftefe::utils::MemorySpace memorySpace>
68 std::vector<double>
69 amaxsMultiVector(size_type vecSize,
70 size_type numVec,
71 ValueType const * multiVecData,
72 LinAlgOpContext<memorySpace> &context);
73
74
75 template <typename ValueType1,
76 typename ValueType2,
77 typename dftefe::utils::MemorySpace memorySpace>
78 void
79 axpy(size_type n,
80 scalar_type<ValueType1, ValueType2> alpha,
81 ValueType1 const * x,
82 size_type incx,
83 ValueType2 * y,
84 size_type incy,
85 LinAlgOpContext<memorySpace> & context);
86
87 // i have neglected incx & incy parameters
99 template <typename ValueType1,
100 typename ValueType2,
101 typename dftefe::utils::MemorySpace memorySpace>
102 void
103 reciprocalX(size_type n,
104 const ValueType1 alpha,
105 ValueType2 const * x,
106 scalar_type<ValueType1, ValueType2> *y,
107 LinAlgOpContext<memorySpace> & context);
108
109
117 template <typename ValueType1,
118 typename ValueType2,
119 typename dftefe::utils::MemorySpace memorySpace>
120 void
121 ascale(size_type n,
122 ValueType1 alpha,
123 const ValueType2 * x,
124 scalar_type<ValueType1, ValueType2> *z,
125 LinAlgOpContext<memorySpace> & context);
126
127
135 template <typename ValueType1,
136 typename ValueType2,
137 typename dftefe::utils::MemorySpace memorySpace>
138 void
139 hadamardProduct(size_type n,
140 const ValueType1 * x,
141 const ValueType2 * y,
142 scalar_type<ValueType1, ValueType2> *z,
143 LinAlgOpContext<memorySpace> & context);
144
145 // /*
146 // * @brief Template for performing \f$ blockedOutput_ij = blockedInput_ij * singleVectorInput_i$
147 // * @param[in] size size of the blocked Input array
148 // * @param[in] numComponets no of componets
149 // * @param[in] blockedInput blocked array
150 // * @param[in] singleVectorInput array
151 // * @param[out] blockedOutput blocked array
152 // */
153 // template <typename ValueType1,
154 // typename ValueType2,
155 // typename dftefe::utils::MemorySpace memorySpace>
156 // void
157 // blockedHadamardProduct(const size_type n,
158 // const size_type blockSize,
159 // const ValueType1 * blockedInput,
160 // const ValueType2 * singleVectorInput,
161 // scalar_type<ValueType1, ValueType2> *blockedOutput,
162 // LinAlgOpContext<memorySpace> & context);
163
164
180 template <typename ValueType1,
181 typename ValueType2,
182 typename dftefe::utils::MemorySpace memorySpace>
183 void
184 hadamardProduct(size_type n,
185 const ValueType1 * x,
186 const ValueType2 * y,
187 const ScalarOp & opx,
188 const ScalarOp & opy,
189 scalar_type<ValueType1, ValueType2> *z,
190 LinAlgOpContext<memorySpace> & context);
191
217 template <typename ValueType1,
218 typename ValueType2,
219 dftefe::utils::MemorySpace memorySpace>
220 void
221 scaleStridedVarBatched(const size_type numMats,
222 const Layout layout,
223 const ScalarOp & scalarOpA,
224 const ScalarOp & scalarOpB,
225 const size_type * stridea,
226 const size_type * strideb,
227 const size_type * stridec,
228 const size_type * m,
229 const size_type * n,
230 const size_type * k,
231 const ValueType1 * dA,
232 const ValueType2 * dB,
233 scalar_type<ValueType1, ValueType2> *dC,
234 LinAlgOpContext<memorySpace> & context);
235
258 template <typename ValueType1,
259 typename ValueType2,
260 typename dftefe::utils::MemorySpace memorySpace>
261 void
262 khatriRaoProduct(const Layout layout,
263 size_type sizeI,
264 size_type sizeJ,
265 size_type sizeK,
266 const ValueType1 * A,
267 const ValueType2 * B,
268 scalar_type<ValueType1, ValueType2> *Z,
269 LinAlgOpContext<memorySpace> & context);
270
271
294 template <typename ValueType1,
295 typename ValueType2,
296 typename dftefe::utils::MemorySpace memorySpace>
297 void
298 transposedKhatriRaoProduct(const Layout layout,
299 size_type sizeI,
300 size_type sizeJ,
301 size_type sizeK,
302 const ValueType1 * A,
303 const ValueType2 * B,
304 scalar_type<ValueType1, ValueType2> *Z,
305 LinAlgOpContext<memorySpace> & context);
306
307
317 template <typename ValueType1,
318 typename ValueType2,
319 typename dftefe::utils::MemorySpace memorySpace>
320 void
321 axpby(size_type n,
322 scalar_type<ValueType1, ValueType2> alpha,
323 ValueType1 const * x,
324 scalar_type<ValueType1, ValueType2> beta,
325 const ValueType2 * y,
326 scalar_type<ValueType1, ValueType2> *z,
327 LinAlgOpContext<memorySpace> & context);
328
338 template <typename ValueType1,
339 typename ValueType2,
340 typename dftefe::utils::MemorySpace memorySpace>
341 void
342 axpbyBlocked(const size_type n,
343 const size_type blockSize,
344 const scalar_type<ValueType1, ValueType2> alpha1,
345 const scalar_type<ValueType1, ValueType2> *alpha,
346 const ValueType1 * x,
347 const scalar_type<ValueType1, ValueType2> beta1,
348 const scalar_type<ValueType1, ValueType2> *beta,
349 const ValueType2 * y,
350 scalar_type<ValueType1, ValueType2> * z,
351 LinAlgOpContext<memorySpace> & context);
352
353
354 template <typename ValueType1,
355 typename ValueType2,
356 typename dftefe::utils::MemorySpace memorySpace>
357 scalar_type<ValueType1, ValueType2>
358 dot(size_type n,
359 ValueType1 const * x,
360 size_type incx,
361 ValueType2 const * y,
362 size_type incy,
363 LinAlgOpContext<memorySpace> &context);
364
365
383 template <typename ValueType1,
384 typename ValueType2,
385 typename dftefe::utils::MemorySpace memorySpace>
386 void
387 dotMultiVector(size_type vecSize,
388 size_type numVec,
389 const ValueType1 * multiVecDataX,
390 const ValueType2 * multiVecDataY,
391 const ScalarOp & opX,
392 const ScalarOp & opY,
393 scalar_type<ValueType1, ValueType2> *multiVecDotProduct,
394 LinAlgOpContext<memorySpace> & context);
395
396
397 template <typename ValueType,
398 typename dftefe::utils::MemorySpace memorySpace>
399 real_type<ValueType>
400 nrm2(size_type n,
401 ValueType const * x,
402 size_type incx,
403 LinAlgOpContext<memorySpace> &context);
404
414 template <typename ValueType,
415 typename dftefe::utils::MemorySpace memorySpace>
416 std::vector<double>
417 nrms2MultiVector(size_type vecSize,
418 size_type numVec,
419 ValueType const * multiVecData,
420 LinAlgOpContext<memorySpace> &context);
421
422 template <typename ValueType1,
423 typename ValueType2,
424 typename dftefe::utils::MemorySpace memorySpace>
425 void
426 gemm(const char & transA,
427 const char & transB,
428 const size_type m,
429 const size_type n,
430 const size_type k,
431 const scalar_type<ValueType1, ValueType2> alpha,
432 ValueType1 const * dA,
433 const size_type ldda,
434 ValueType2 const * dB,
435 const size_type lddb,
436 const scalar_type<ValueType1, ValueType2> beta,
437 scalar_type<ValueType1, ValueType2> * dC,
438 const size_type lddc,
439 LinAlgOpContext<memorySpace> & context);
440
447 template <typename ValueType1,
448 typename ValueType2,
449 typename dftefe::utils::MemorySpace memorySpace>
450 void
451 gemmStridedVarBatched(size_type numMats,
452 const char * transA,
453 const char * transB,
454 const size_type * stridea,
455 const size_type * strideb,
456 const size_type * stridec,
457 const size_type * m,
458 const size_type * n,
459 const size_type * k,
460 scalar_type<ValueType1, ValueType2> alpha,
461 const ValueType1 * dA,
462 const size_type * ldda,
463 const ValueType2 * dB,
464 const size_type * lddb,
465 scalar_type<ValueType1, ValueType2> beta,
466 scalar_type<ValueType1, ValueType2> *dC,
467 const size_type * lddc,
468 LinAlgOpContext<memorySpace> & context);
469
470
474 template <typename ValueType,
475 typename dftefe::utils::MemorySpace memorySpace>
476 LapackError
477 inverse(size_type n, ValueType *A, LinAlgOpContext<memorySpace> &context);
478
482 template <typename ValueType,
483 typename dftefe::utils::MemorySpace memorySpace>
484 LapackError
485 trtri(const char uplo,
486 const char diag,
487 size_type n,
488 ValueType * A,
489 size_type lda,
490 LinAlgOpContext<memorySpace> &context);
491
495 template <typename ValueType,
496 typename dftefe::utils::MemorySpace memorySpace>
497 LapackError
498 potrf(const char uplo,
499 size_type n,
500 ValueType * A,
501 size_type lda,
502 LinAlgOpContext<memorySpace> &context);
503
507 template <typename ValueType,
508 typename dftefe::utils::MemorySpace memorySpace>
509 LapackError
510 steqr(const char jobz,
511 size_type n,
512 real_type<ValueType> * D,
513 real_type<ValueType> * E,
514 ValueType * Z,
515 size_type ldz,
516 LinAlgOpContext<memorySpace> &context);
517
521 template <typename ValueType,
522 typename dftefe::utils::MemorySpace memorySpace>
523 LapackError
524 heevd(const char jobz,
525 const char uplo,
526 size_type n,
527 ValueType * A,
528 size_type lda,
529 real_type<ValueType> * W,
530 LinAlgOpContext<memorySpace> &context);
531
535 template <typename ValueType,
536 typename dftefe::utils::MemorySpace memorySpace>
537 LapackError
538 hegv(size_type itype,
539 const char jobz,
540 const char uplo,
541 size_type n,
542 ValueType * A,
543 size_type lda,
544 ValueType * B,
545 size_type ldb,
546 real_type<ValueType> * W,
547 LinAlgOpContext<memorySpace> &context);
548
553 template <typename ValueType,
554 typename dftefe::utils::MemorySpace memorySpace>
555 LapackError
556 gesv(size_type n,
557 size_type nrhs,
558 ValueType * A,
559 size_type lda,
560 ValueType * B,
561 size_type ldb,
562 LinAlgOpContext<memorySpace> &context);
563
564 } // namespace blasLapack
565 } // namespace linearAlgebra
566} // namespace dftefe
567
568#include "BlasLapack.t.cpp"
569#endif // dftefeBlasWrappers_h
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:210
dftefe::linearAlgebra::blasLapack::amax
real_type< ValueType > amax(size_type n, ValueType const *x, size_type incx, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:28
dftefe::linearAlgebra::blasLapack::gesv
LapackError gesv(size_type n, size_type nrhs, ValueType *A, size_type lda, ValueType *B, size_type ldb, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:636
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:281
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:108
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:59
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:41
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:193
dftefe::linearAlgebra::blasLapack::Layout
Layout
Definition: BlasLapackTypedef.h:161
dftefe::linearAlgebra::blasLapack::gemmStridedVarBatched
void gemmStridedVarBatched(const size_type numMats, const char *transA, const char *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:391
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:304
dftefe::linearAlgebra::blasLapack::potrf
LapackError potrf(const char uplo, size_type n, ValueType *A, size_type lda, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:522
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:318
dftefe::linearAlgebra::blasLapack::asum
real_type< ValueType > asum(size_type n, ValueType const *x, size_type incx, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:16
dftefe::linearAlgebra::blasLapack::hegv
LapackError hegv(size_type itype, const char jobz, const char 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:604
dftefe::linearAlgebra::blasLapack::trtri
LapackError trtri(const char uplo, const char diag, size_type n, ValueType *A, size_type lda, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:495
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:228
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:264
dftefe::linearAlgebra::blasLapack::scaleStridedVarBatched
void scaleStridedVarBatched(const size_type numMats, const Layout layout, 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:157
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:78
dftefe::linearAlgebra::blasLapack::ScalarOp
ScalarOp
Definition: BlasLapackTypedef.h:169
dftefe::linearAlgebra::blasLapack::steqr
LapackError steqr(const char jobz, size_type n, real_type< ValueType > *D, real_type< ValueType > *E, ValueType *Z, size_type ldz, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:548
dftefe::linearAlgebra::blasLapack::gemm
void gemm(const char &transA, const char &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:332
dftefe::linearAlgebra::blasLapack::axpbyBlocked
void axpbyBlocked(const size_type n, const size_type blockSize, const scalar_type< ValueType1, ValueType2 > alpha1, const scalar_type< ValueType1, ValueType2 > *alpha, const ValueType1 *x, const scalar_type< ValueType1, ValueType2 > beta1, const scalar_type< ValueType1, ValueType2 > *beta, const ValueType2 *y, scalar_type< ValueType1, ValueType2 > *z, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:244
dftefe::linearAlgebra::blasLapack::inverse
LapackError inverse(size_type n, ValueType *A, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:469
dftefe::linearAlgebra::blasLapack::heevd
LapackError heevd(const char jobz, const char uplo, size_type n, ValueType *A, size_type lda, real_type< ValueType > *W, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:576
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:92
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