elpa1_auxiliary.F90 24.3 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
!    This file is part of ELPA.
!
!    The ELPA library was originally created by the ELPA consortium,
!    consisting of the following organizations:
!
!    - Max Planck Computing and Data Facility (MPCDF), formerly known as
!      Rechenzentrum Garching der Max-Planck-Gesellschaft (RZG),
!    - Bergische Universität Wuppertal, Lehrstuhl für angewandte
!      Informatik,
!    - Technische Universität München, Lehrstuhl für Informatik mit
!      Schwerpunkt Wissenschaftliches Rechnen ,
!    - Fritz-Haber-Institut, Berlin, Abt. Theorie,
!    - Max-Plack-Institut für Mathematik in den Naturwissenschaften,
!      Leipzig, Abt. Komplexe Strukutren in Biologie und Kognition,
!      and
!    - IBM Deutschland GmbH
!
!    This particular source code file contains additions, changes and
!    enhancements authored by Intel Corporation which is not part of
!    the ELPA consortium.
!
!    More information can be found here:
!    http://elpa.mpcdf.mpg.de/
!
!    ELPA is free software: you can redistribute it and/or modify
!    it under the terms of the version 3 of the license of the
!    GNU Lesser General Public License as published by the Free
!    Software Foundation.
!
!    ELPA is distributed in the hope that it will be useful,
!    but WITHOUT ANY WARRANTY; without even the implied warranty of
!    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
!    GNU Lesser General Public License for more details.
!
!    You should have received a copy of the GNU Lesser General Public License
!    along with ELPA.  If not, see <http://www.gnu.org/licenses/>
!
!    ELPA reflects a substantial effort on the part of the original
!    ELPA consortium, and we ask you to respect the spirit of the
!    license that we chose: i.e., please contribute any changes you
!    may have back to the original ELPA library distribution, and keep
!    any derivatives of ELPA under the same license that we chose for
!    the original distribution, the GNU Lesser General Public License.
!
!
! ELPA1 -- Faster replacements for ScaLAPACK symmetric eigenvalue routines
!
! Copyright of the original code rests with the authors inside the ELPA
! consortium. The copyright of any additional modifications shall rest
! with their original authors, but shall adhere to the licensing terms
! distributed along with the original code in the file "COPYING".
!
! This file has been rewritten by A. Marek, MPCDF
#include "config-f90.h"

!> \brief Fortran module which provides helper routines for matrix calculations
57
module elpa1_auxiliary_impl
58
59
60
61
  use elpa_utilities

  implicit none

62
  public :: elpa_mult_at_b_real_double_impl      !< Multiply double-precision real matrices A**T * B
63

64
  public :: elpa_mult_ah_b_complex_double_impl   !< Multiply double-precision complex matrices A**H * B
65

66
  public :: elpa_invert_trm_real_double_impl    !< Invert double-precision real triangular matrix
67

68
  public :: elpa_invert_trm_complex_double_impl  !< Invert double-precision complex triangular matrix
69

70
  public :: elpa_cholesky_real_double_impl       !< Cholesky factorization of a double-precision real matrix
71

72
  public :: elpa_cholesky_complex_double_impl    !< Cholesky factorization of a double-precision complex matrix
73

74
  public :: elpa_solve_tridi_double_impl         !< Solve tridiagonal eigensystem for a double-precision matrix with divide and conquer method
75
76

#ifdef WANT_SINGLE_PRECISION_REAL
77
78
79
80
  public :: elpa_cholesky_real_single_impl       !< Cholesky factorization of a single-precision real matrix
  public :: elpa_invert_trm_real_single_impl     !< Invert single-precision real triangular matrix
  public :: elpa_mult_at_b_real_single_impl      !< Multiply single-precision real matrices A**T * B
  public :: elpa_solve_tridi_single_impl         !< Solve tridiagonal eigensystem for a single-precision matrix with divide and conquer method
81
82
83
#endif

#ifdef WANT_SINGLE_PRECISION_COMPLEX
84
85
86
  public :: elpa_cholesky_complex_single_impl    !< Cholesky factorization of a single-precision complex matrix
  public :: elpa_invert_trm_complex_single_impl  !< Invert single-precision complex triangular matrix
  public :: elpa_mult_ah_b_complex_single_impl   !< Multiply single-precision complex matrices A**H * B
87
88
89
90
91
92
#endif

  contains

#define REALCASE 1
#define DOUBLE_PRECISION
93
#include "../general/precision_macros.h"
94

95
   function elpa_cholesky_real_double_impl (na, a, lda, nblk, matrixCols, mpi_comm_rows, mpi_comm_cols, &
96
                                            wantDebug) result(success)
97
#include "elpa_cholesky_template.X90"
98

99
    end function elpa_cholesky_real_double_impl
100
101
#undef DOUBLE_PRECISION
#undef REALCASE
102
103
104
105

#ifdef WANT_SINGLE_PRECISION_REAL
#define REALCASE 1
#define SINGLE_PRECISION
106
#include "../general/precision_macros.h"
107

108
   function elpa_cholesky_real_single_impl(na, a, lda, nblk, matrixCols, mpi_comm_rows, mpi_comm_cols, &
109
                                            wantDebug) result(success)
110
#include "elpa_cholesky_template.X90"
111

112
    end function elpa_cholesky_real_single_impl
113
114
#undef SINGLE_PRECISION
#undef REALCASE
115
116
117
118
119

#endif /* WANT_SINGLE_PRECSION_REAL */

#define REALCASE 1
#define DOUBLE_PRECISION
120
#include "../general/precision_macros.h"
121
122
123
124
125
126
127
128
129
130
131
132
133
134
!> \brief  elpa_invert_trm_real_double: Inverts a double-precision real upper triangular matrix
!> \details
!> \param  na                   Order of matrix
!> \param  a(lda,matrixCols)    Distributed matrix which should be inverted
!>                              Distribution is like in Scalapack.
!>                              Only upper triangle needs to be set.
!>                              The lower triangle is not referenced.
!> \param  lda                  Leading dimension of a
!> \param  nblk                 blocksize of cyclic distribution, must be the same in both directions!
!> \param  matrixCols           local columns of matrix a
!> \param  mpi_comm_rows        MPI communicator for rows
!> \param  mpi_comm_cols        MPI communicator for columns
!> \param wantDebug             logical, more debug information on failure
!> \result succes               logical, reports success or failure
135
    function elpa_invert_trm_real_double_impl(na, a, lda, nblk, matrixCols, mpi_comm_rows, &
136
                                             mpi_comm_cols, wantDebug) result(success)
137
#include "elpa_invert_trm.X90"
138
     end function elpa_invert_trm_real_double_impl
139
140
#undef DOUBLE_PRECISION
#undef REALCASE
141
142
143
144

#if WANT_SINGLE_PRECISION_REAL
#define REALCASE 1
#define SINGLE_PRECISION
145
#include "../general/precision_macros.h"
146

147
!> \brief  elpa_invert_trm_real_single_impl: Inverts a single-precision real upper triangular matrix
148
149
150
151
152
153
154
155
156
157
158
159
160
!> \details
!> \param  na                   Order of matrix
!> \param  a(lda,matrixCols)    Distributed matrix which should be inverted
!>                              Distribution is like in Scalapack.
!>                              Only upper triangle needs to be set.
!>                              The lower triangle is not referenced.
!> \param  lda                  Leading dimension of a
!> \param                       matrixCols  local columns of matrix a
!> \param  nblk                 blocksize of cyclic distribution, must be the same in both directions!
!> \param  mpi_comm_rows        MPI communicator for rows
!> \param  mpi_comm_cols        MPI communicator for columns
!> \param wantDebug             logical, more debug information on failure
!> \result succes               logical, reports success or failure
161
    function elpa_invert_trm_real_single_impl(na, a, lda, nblk, matrixCols, mpi_comm_rows, &
162
                                             mpi_comm_cols, wantDebug) result(success)
163
#include "elpa_invert_trm.X90"
164
    end function elpa_invert_trm_real_single_impl
165
166
#undef SINGLE_PRECISION
#undef REALCASE
167
168
169
170
171
172

#endif /* WANT_SINGLE_PRECISION_REAL */


#define COMPLEXCASE 1
#define DOUBLE_PRECISION
173
#include "../general/precision_macros.h"
174

175
!> \brief  elpa_cholesky_complex_double_impl: Cholesky factorization of a double-precision complex hermitian matrix
176
177
178
179
180
181
182
183
184
185
186
187
188
189
!> \details
!> \param  na                   Order of matrix
!> \param  a(lda,matrixCols)    Distributed matrix which should be factorized.
!>                              Distribution is like in Scalapack.
!>                              Only upper triangle needs to be set.
!>                              On return, the upper triangle contains the Cholesky factor
!>                              and the lower triangle is set to 0.
!> \param  lda                  Leading dimension of a
!> \param                       matrixCols  local columns of matrix a
!> \param  nblk                 blocksize of cyclic distribution, must be the same in both directions!
!> \param  mpi_comm_rows        MPI communicator for rows
!> \param  mpi_comm_cols        MPI communicator for columns
!> \param wantDebug             logical, more debug information on failure
!> \result succes               logical, reports success or failure
190
191
    function elpa_cholesky_complex_double_impl(na, a, lda, nblk, matrixCols, mpi_comm_rows, mpi_comm_cols, &
                                               wantDebug) result(success)
192

193
#include "elpa_cholesky_template.X90"
194

195
    end function elpa_cholesky_complex_double_impl
196
197
#undef DOUBLE_PRECISION
#undef COMPLEXCASE
198
199
200
201

#ifdef WANT_SINGLE_PRECISION_COMPLEX
#define COMPLEXCASE 1
#define SINGLE_PRECISION
202
#include "../general/precision_macros.h"
203

204
!> \brief  elpa_cholesky_complex_single_impl: Cholesky factorization of a single-precision complex hermitian matrix
205
206
207
208
209
210
211
212
213
214
215
216
217
218
!> \details
!> \param  na                   Order of matrix
!> \param  a(lda,matrixCols)    Distributed matrix which should be factorized.
!>                              Distribution is like in Scalapack.
!>                              Only upper triangle needs to be set.
!>                              On return, the upper triangle contains the Cholesky factor
!>                              and the lower triangle is set to 0.
!> \param  lda                  Leading dimension of a
!> \param                       matrixCols  local columns of matrix a
!> \param  nblk                 blocksize of cyclic distribution, must be the same in both directions!
!> \param  mpi_comm_rows        MPI communicator for rows
!> \param  mpi_comm_cols        MPI communicator for columns
!> \param wantDebug             logical, more debug information on failure
!> \result succes               logical, reports success or failure
219
220
    function elpa_cholesky_complex_single_impl(na, a, lda, nblk, matrixCols, mpi_comm_rows, mpi_comm_cols, &
                                               wantDebug) result(success)
221

222
#include "elpa_cholesky_template.X90"
223

224
    end function elpa_cholesky_complex_single_impl
225
226
#undef SINGLE_PRECISION
#undef COMPLEXCASE
227
228
229
230
231

#endif /* WANT_SINGLE_PRECISION_COMPLEX */

#define COMPLEXCASE 1
#define DOUBLE_PRECISION
232
#include "../general/precision_macros.h"
233

234
!> \brief  elpa_invert_trm_complex_double_impl: Inverts a double-precision complex upper triangular matrix
235
236
237
238
239
240
241
242
243
244
245
246
247
248
!> \details
!> \param  na                   Order of matrix
!> \param  a(lda,matrixCols)    Distributed matrix which should be inverted
!>                              Distribution is like in Scalapack.
!>                              Only upper triangle needs to be set.
!>                              The lower triangle is not referenced.
!> \param  lda                  Leading dimension of a
!> \param                       matrixCols  local columns of matrix a
!> \param  nblk                 blocksize of cyclic distribution, must be the same in both directions!
!> \param  mpi_comm_rows        MPI communicator for rows
!> \param  mpi_comm_cols        MPI communicator for columns
!> \param wantDebug             logical, more debug information on failure
!> \result succes               logical, reports success or failure

249
     function elpa_invert_trm_complex_double_impl(na, a, lda, nblk, matrixCols, mpi_comm_rows, &
250
                                                 mpi_comm_cols, wantDebug) result(success)
251
#include "elpa_invert_trm.X90"
252
    end function elpa_invert_trm_complex_double_impl
253
254
#undef DOUBLE_PRECISION
#undef COMPLEXCASE
255
256
257
258

#ifdef WANT_SINGLE_PRECISION_COMPLEX
#define COMPLEXCASE 1
#define SINGLE_PRECISION
259
#include "../general/precision_macros.h"
260

261
!> \brief  elpa_invert_trm_complex_single_impl: Inverts a single-precision complex upper triangular matrix
262
263
264
265
266
267
268
269
270
271
272
273
274
275
!> \details
!> \param  na                   Order of matrix
!> \param  a(lda,matrixCols)    Distributed matrix which should be inverted
!>                              Distribution is like in Scalapack.
!>                              Only upper triangle needs to be set.
!>                              The lower triangle is not referenced.
!> \param  lda                  Leading dimension of a
!> \param                       matrixCols  local columns of matrix a
!> \param  nblk                 blocksize of cyclic distribution, must be the same in both directions!
!> \param  mpi_comm_rows        MPI communicator for rows
!> \param  mpi_comm_cols        MPI communicator for columns
!> \param wantDebug             logical, more debug information on failure
!> \result succes               logical, reports success or failure

276
    function elpa_invert_trm_complex_single_impl(na, a, lda, nblk, matrixCols, mpi_comm_rows, &
277
                                                mpi_comm_cols, wantDebug) result(success)
278
#include "elpa_invert_trm.X90"
279
    end function elpa_invert_trm_complex_single_impl
280
281
#undef SINGLE_PRECISION
#undef COMPLEXCASE
282
283
284
285
286

#endif /* WANT_SINGE_PRECISION_COMPLEX */

#define REALCASE 1
#define DOUBLE_PRECISION
287
#include "../general/precision_macros.h"
288
    function elpa_mult_at_b_real_double_impl(uplo_a, uplo_c, na, ncb, a, lda, ldaCols, b, ldb, ldbCols, nblk, &
289
                              mpi_comm_rows, mpi_comm_cols, c, ldc, ldcCols) result(success)
290
#include "elpa_multiply_a_b.X90"
291
    end function elpa_mult_at_b_real_double_impl
292
293
#undef DOUBLE_PRECISION
#undef REALCASE
294
295
296
297

#if WANT_SINGLE_PRECISION_REAL
#define REALCASE 1
#define SINGLE_PRECISION
298
#include "../general/precision_macros.h"
299

300
!> \brief  elpa_mult_at_b_real_single_impl: Performs C : = A**T * B
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
!>         where   A is a square matrix (na,na) which is optionally upper or lower triangular
!>                 B is a (na,ncb) matrix
!>                 C is a (na,ncb) matrix where optionally only the upper or lower
!>                   triangle may be computed
!> \details

!> \param  uplo_a               'U' if A is upper triangular
!>                              'L' if A is lower triangular
!>                              anything else if A is a full matrix
!>                              Please note: This pertains to the original A (as set in the calling program)
!>                                           whereas the transpose of A is used for calculations
!>                              If uplo_a is 'U' or 'L', the other triangle is not used at all,
!>                              i.e. it may contain arbitrary numbers
!> \param uplo_c                'U' if only the upper diagonal part of C is needed
!>                              'L' if only the upper diagonal part of C is needed
!>                              anything else if the full matrix C is needed
!>                              Please note: Even when uplo_c is 'U' or 'L', the other triangle may be
!>                                            written to a certain extent, i.e. one shouldn't rely on the content there!
!> \param na                    Number of rows/columns of A, number of rows of B and C
!> \param ncb                   Number of columns  of B and C
!> \param a                     matrix a
!> \param lda                   leading dimension of matrix a
!> \param b                     matrix b
!> \param ldb                   leading dimension of matrix b
!> \param nblk                  blocksize of cyclic distribution, must be the same in both directions!
!> \param  mpi_comm_rows        MPI communicator for rows
!> \param  mpi_comm_cols        MPI communicator for columns
!> \param c                     matrix c
!> \param ldc                   leading dimension of matrix c
!> \result success

332
    function elpa_mult_at_b_real_single_impl(uplo_a, uplo_c, na, ncb, a, lda, ldaCols, b, ldb, ldbCols, nblk, &
333
334
                              mpi_comm_rows, mpi_comm_cols, c, ldc, ldcCols) result(success)

335
#include "elpa_multiply_a_b.X90"
336

337
    end function elpa_mult_at_b_real_single_impl
338
339
#undef SINGLE_PRECISION
#undef REALCASE
340
341
342
343
344
#endif /* WANT_SINGLE_PRECISION_REAL */


#define COMPLEXCASE 1
#define DOUBLE_PRECISION
345
#include "../general/precision_macros.h"
346

347
!> \brief  elpa_mult_ah_b_complex_double_impl: Performs C : = A**H * B
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
!>         where   A is a square matrix (na,na) which is optionally upper or lower triangular
!>                 B is a (na,ncb) matrix
!>                 C is a (na,ncb) matrix where optionally only the upper or lower
!>                   triangle may be computed
!> \details
!>
!> \param  uplo_a               'U' if A is upper triangular
!>                              'L' if A is lower triangular
!>                              anything else if A is a full matrix
!>                              Please note: This pertains to the original A (as set in the calling program)
!>                                           whereas the transpose of A is used for calculations
!>                              If uplo_a is 'U' or 'L', the other triangle is not used at all,
!>                              i.e. it may contain arbitrary numbers
!> \param uplo_c                'U' if only the upper diagonal part of C is needed
!>                              'L' if only the upper diagonal part of C is needed
!>                              anything else if the full matrix C is needed
!>                              Please note: Even when uplo_c is 'U' or 'L', the other triangle may be
!>                                            written to a certain extent, i.e. one shouldn't rely on the content there!
!> \param na                    Number of rows/columns of A, number of rows of B and C
!> \param ncb                   Number of columns  of B and C
!> \param a                     matrix a
!> \param lda                   leading dimension of matrix a
!> \param ldaCols               columns of matrix a
!> \param b                     matrix b
!> \param ldb                   leading dimension of matrix b
!> \param ldbCols               columns of matrix b
!> \param nblk                  blocksize of cyclic distribution, must be the same in both directions!
!> \param  mpi_comm_rows        MPI communicator for rows
!> \param  mpi_comm_cols        MPI communicator for columns
!> \param c                     matrix c
!> \param ldc                   leading dimension of matrix c
!> \result success

381
    function elpa_mult_ah_b_complex_double_impl(uplo_a, uplo_c, na, ncb, a, lda, ldaCols, b, ldb, ldbCols, nblk, &
382
                                 mpi_comm_rows, mpi_comm_cols, c, ldc, ldcCols) result(success)
383
#include "elpa_multiply_a_b.X90"
384

385
    end function elpa_mult_ah_b_complex_double_impl
386
387
#undef DOUBLE_PRECISION
#undef COMPLEXCASE
388
389
390
391

#ifdef WANT_SINGLE_PRECISION_COMPLEX
#define COMPLEXCASE 1
#define SINGLE_PRECISION
392
#include "../general/precision_macros.h"
393

394
!> \brief  elpa_mult_ah_b_complex_single_impl: Performs C : = A**H * B
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
!>         where   A is a square matrix (na,na) which is optionally upper or lower triangular
!>                 B is a (na,ncb) matrix
!>                 C is a (na,ncb) matrix where optionally only the upper or lower
!>                   triangle may be computed
!> \details
!>
!> \param  uplo_a               'U' if A is upper triangular
!>                              'L' if A is lower triangular
!>                              anything else if A is a full matrix
!>                              Please note: This pertains to the original A (as set in the calling program)
!>                                           whereas the transpose of A is used for calculations
!>                              If uplo_a is 'U' or 'L', the other triangle is not used at all,
!>                              i.e. it may contain arbitrary numbers
!> \param uplo_c                'U' if only the upper diagonal part of C is needed
!>                              'L' if only the upper diagonal part of C is needed
!>                              anything else if the full matrix C is needed
!>                              Please note: Even when uplo_c is 'U' or 'L', the other triangle may be
!>                                            written to a certain extent, i.e. one shouldn't rely on the content there!
!> \param na                    Number of rows/columns of A, number of rows of B and C
!> \param ncb                   Number of columns  of B and C
!> \param a                     matrix a
!> \param lda                   leading dimension of matrix a
!> \param ldaCols               columns of matrix a
!> \param b                     matrix b
!> \param ldb                   leading dimension of matrix b
!> \param ldbCols               columns of matrix b
!> \param nblk                  blocksize of cyclic distribution, must be the same in both directions!
!> \param  mpi_comm_rows        MPI communicator for rows
!> \param  mpi_comm_cols        MPI communicator for columns
!> \param c                     matrix c
!> \param ldc                   leading dimension of matrix c
!> \result success

428
    function elpa_mult_ah_b_complex_single_impl(uplo_a, uplo_c, na, ncb, a, lda, ldaCols, b, ldb, ldbCols, nblk, &
429
430
                                 mpi_comm_rows, mpi_comm_cols, c, ldc, ldcCols) result(success)

431
#include "elpa_multiply_a_b.X90"
432

433
    end function elpa_mult_ah_b_complex_single_impl
434
435
#undef SINGLE_PRECISION
#undef COMPLEXCASE
436
437
438
439
#endif /* WANT_SINGLE_PRECISION_COMPLEX */

#define REALCASE 1
#define DOUBLE_PRECISION
440
#include "../general/precision_macros.h"
441

442
!> \brief  elpa_solve_tridi_double_impl: Solve tridiagonal eigensystem for a double-precision matrix with divide and conquer method
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
!> \details
!>
!> \param na                    Matrix dimension
!> \param nev                   number of eigenvalues/vectors to be computed
!> \param d                     array d(na) on input diagonal elements of tridiagonal matrix, on
!>                              output the eigenvalues in ascending order
!> \param e                     array e(na) on input subdiagonal elements of matrix, on exit destroyed
!> \param q                     on exit : matrix q(ldq,matrixCols) contains the eigenvectors
!> \param ldq                   leading dimension of matrix q
!> \param nblk                  blocksize of cyclic distribution, must be the same in both directions!
!> \param matrixCols            columns of matrix q
!> \param mpi_comm_rows         MPI communicator for rows
!> \param mpi_comm_cols         MPI communicator for columns
!> \param wantDebug             logical, give more debug information if .true.
!> \result success              logical, .true. on success, else .false.

459
    function elpa_solve_tridi_double_impl(na, nev, d, e, q, ldq, nblk, matrixCols, mpi_comm_rows, mpi_comm_cols, wantDebug) &
460
461
          result(success)

462
#include "elpa_solve_tridi_impl_public.X90"
463
464

    end function
465
466
#undef DOUBLE_PRECISION
#undef REALCASE
467
468
469
470

#ifdef WANT_SINGLE_PRECISION_REAL
#define REALCASE 1
#define SINGLE_PRECISION
471
#include "../general/precision_macros.h"
472

473
!> \brief  elpa_solve_tridi_single_impl: Solve tridiagonal eigensystem for a single-precision matrix with divide and conquer method
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
!> \details
!>
!> \param na                    Matrix dimension
!> \param nev                   number of eigenvalues/vectors to be computed
!> \param d                     array d(na) on input diagonal elements of tridiagonal matrix, on
!>                              output the eigenvalues in ascending order
!> \param e                     array e(na) on input subdiagonal elements of matrix, on exit destroyed
!> \param q                     on exit : matrix q(ldq,matrixCols) contains the eigenvectors
!> \param ldq                   leading dimension of matrix q
!> \param nblk                  blocksize of cyclic distribution, must be the same in both directions!
!> \param matrixCols            columns of matrix q
!> \param mpi_comm_rows         MPI communicator for rows
!> \param mpi_comm_cols         MPI communicator for columns
!> \param wantDebug             logical, give more debug information if .true.
!> \result success              logical, .true. on success, else .false.

490
    function elpa_solve_tridi_single_impl(na, nev, d, e, q, ldq, nblk, matrixCols, mpi_comm_rows, &
491
492
                                     mpi_comm_cols, wantDebug) result(success)

493
#include "elpa_solve_tridi_impl_public.X90"
494
495

    end function
496
497
#undef SINGLE_PRECISION
#undef REALCASE
498
499
500
501
502
#endif /* WANT_SINGLE_PRECISION_REAL */




503
end module elpa1_auxiliary_impl
504