Octopus
lalg_adv.F90
Go to the documentation of this file.
1!! Copyright (C) 2002-2006 M. Marques, A. Castro, A. Rubio, G. Bertsch
2!!
3!! This program is free software; you can redistribute it and/or modify
4!! it under the terms of the GNU General Public License as published by
5!! the Free Software Foundation; either version 2, or (at your option)
6!! any later version.
7!!
8!! This program is distributed in the hope that it will be useful,
9!! but WITHOUT ANY WARRANTY; without even the implied warranty of
10!! MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11!! GNU General Public License for more details.
12!!
13!! You should have received a copy of the GNU General Public License
14!! along with this program; if not, write to the Free Software
15!! Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
16!! 02110-1301, USA.
17!!
18
19#include "global.h"
20
21module lalg_adv_oct_m
22 use blas_oct_m
24 use blacs_oct_m
25 use debug_oct_m
26 use global_oct_m
27#ifndef NDEBUG
28 use, intrinsic :: ieee_exceptions
29#endif
30 use, intrinsic :: iso_fortran_env
31 use lapack_oct_m
33 use math_oct_m
35 use mpi_oct_m
38 use sort_oct_m
39 use utils_oct_m
40#ifdef HAVE_ELPA
41 use elpa
42#endif
43
44 implicit none
45
46 private
47 public :: &
63 zlalg_exp, &
64 zlalg_phi, &
69 lalg_zdni, &
71 lalg_zd2ni, &
77
78 interface lalg_cholesky
79 module procedure dcholesky, zcholesky
80 end interface lalg_cholesky
81
82 interface lalg_cholesky_pivoted
83 module procedure dcholesky_pivoted, zcholesky_pivoted
84 end interface lalg_cholesky_pivoted
85
86 interface lalg_geneigensolve
87 module procedure dgeneigensolve, zgeneigensolve
88 end interface lalg_geneigensolve
89
90 interface lalg_eigensolve_nonh
91 module procedure zeigensolve_nonh, deigensolve_nonh
92 end interface lalg_eigensolve_nonh
94 interface lalg_eigensolve
95 module procedure deigensolve, zeigensolve
96 end interface lalg_eigensolve
97
100 end interface lalg_eigensolve_tridiagonal
101
104 end interface lalg_eigensolve_parallel
105
108
109 interface lalg_determinant
110 module procedure ddeterminant, zdeterminant
111 end interface lalg_determinant
112
113 interface lalg_inverse
114 module procedure dinverse, zinverse
115 end interface lalg_inverse
116
117 interface lalg_linsyssolve
118 module procedure dlinsyssolve, zlinsyssolve
119 end interface lalg_linsyssolve
120
123 end interface lalg_singular_value_decomp
124
125 interface lalg_pseudo_inverse
127 end interface lalg_pseudo_inverse
128
129 interface lalg_svd_inverse
130 module procedure dsvd_inverse, zsvd_inverse
131 end interface lalg_svd_inverse
132
135 end interface lalg_lowest_geneigensolve
136
137 interface lalg_lowest_eigensolve
138 module procedure dlowest_eigensolve, zlowest_eigensolve
139 end interface lalg_lowest_eigensolve
140
141 interface lapack_geev
142 module procedure lalg_dgeev, lalg_zgeev
143 end interface lapack_geev
144
145 interface lalg_least_squares
146 module procedure dleast_squares_vec, zleast_squares_vec
147 end interface lalg_least_squares
148
149 interface lalg_matrix_function
151 end interface lalg_matrix_function
152
153 interface lalg_matrix_rank_svd
155 end interface lalg_matrix_rank_svd
156
157 interface lalg_qr_factorization
159 end interface lalg_qr_factorization
160
161contains
163 ! ---------------------------------------------------------
165 real(real64) function sfmin()
166 interface
167 real(real64) function dlamch(cmach)
168 import real64
169 implicit none
170 character(1), intent(in) :: cmach
171 end function dlamch
172 end interface
173
174 sfmin = dlamch('S')
175 end function sfmin
176
177 subroutine lalg_dgeev(jobvl, jobvr, n, a, lda, w, vl, ldvl, vr, ldvr, work, lwork, rwork, info)
178 character(1), intent(in) :: jobvl, jobvr
179 integer, intent(in) :: n, lda, ldvl, ldvr, lwork
180 real(real64), contiguous, intent(inout) :: a(:, :)
181 complex(real64), contiguous, intent(out) :: w(:)
182 real(real64), contiguous, intent(out) :: vl(:, :), vr(:, :)
183 real(real64), contiguous, intent(out) :: work(:)
184 real(real64), contiguous, intent(out) :: rwork(:)
185 integer, intent(out) :: info
186
187 real(real64), allocatable :: wr(:), wi(:)
188#ifndef NDEBUG
189 logical :: halting_mode(size(ieee_all))
190#endif
191
192 push_sub(lalg_dgeev)
194 safe_allocate(wr(1:n))
195 safe_allocate(wi(1:n))
196
197#ifndef NDEBUG
198 ! Optimized LAPACK backends (e.g. MKL) may raise spurious floating-point
199 ! exceptions while still returning correct results, so suspend trapping
200 ! for builds that enable it
201 call ieee_get_halting_mode(ieee_all, halting_mode)
202 call ieee_set_halting_mode(ieee_all, .false.)
203#endif
204 call dgeev(jobvl, jobvr, n, a(1, 1), lda, wr(1), wi(1), vl(1, 1), ldvl, vr(1, 1), ldvr, work(1), lwork, info)
205#ifndef NDEBUG
206 call ieee_set_halting_mode(ieee_all, halting_mode)
207#endif
208 w(1:n) = cmplx(wr(1:n), wi(1:n), real64)
210 safe_deallocate_a(wr)
211 safe_deallocate_a(wi)
212
213 pop_sub(lalg_dgeev)
214 end subroutine lalg_dgeev
215
216 subroutine lalg_zgeev(jobvl, jobvr, n, a, lda, w, vl, ldvl, vr, ldvr, work, lwork, rwork, info)
217 character(1), intent(in) :: jobvl, jobvr
218 integer, intent(in) :: n, lda, ldvl, ldvr, lwork
219 complex(real64), contiguous, intent(inout) :: a(:, :)
220 complex(real64), contiguous, intent(out) :: w(:)
221 complex(real64), contiguous, intent(out) :: vl(:, :), vr(:, :)
222 real(real64), contiguous, intent(out) :: rwork(:)
223 complex(real64), contiguous, intent(out) :: work(:)
224 integer, intent(out) :: info
226 push_sub(lalg_zgeev)
227
228 call zgeev(jobvl, jobvr, n, a(1, 1), lda, w(1), vl(1, 1), ldvl, vr(1, 1), ldvr, work(1), lwork, rwork(1), info)
230 pop_sub(lalg_zgeev)
231 end subroutine lalg_zgeev
232
250 subroutine zlalg_exp(nn, pp, aa, ex, hermitian)
251 integer, intent(in) :: nn
252 complex(real64), intent(in) :: pp
253 complex(real64), contiguous, intent(in) :: aa(:, :)
254 complex(real64), contiguous, intent(inout) :: ex(:, :)
255 logical, intent(in) :: hermitian
256
257 complex(real64), allocatable :: evectors(:, :), zevalues(:)
258 real(real64), allocatable :: evalues(:)
259
260 integer :: ii
261
262 push_sub(zlalg_exp)
263
264 safe_allocate(evectors(1:nn, 1:nn))
265
266 if (hermitian) then
267 safe_allocate(evalues(1:nn))
268 safe_allocate(zevalues(1:nn))
269
270 evectors(1:nn, 1:nn) = aa(1:nn, 1:nn)
271
272 call lalg_eigensolve(nn, evectors, evalues)
273
274 zevalues(1:nn) = exp(pp*evalues(1:nn))
275
276 do ii = 1, nn
277 ex(1:nn, ii) = zevalues(1:nn)*conjg(evectors(ii, 1:nn))
278 end do
279
280 ex(:, :) = matmul(evectors(:, :), ex(:, :))
281
282 safe_deallocate_a(evalues)
283 safe_deallocate_a(zevalues)
284 else
285 safe_allocate(zevalues(1:nn))
286
287 evectors(1:nn, 1:nn) = aa(1:nn, 1:nn)
289 call lalg_eigensolve_nonh(nn, evectors, zevalues)
290
291 zevalues(1:nn) = exp(pp*zevalues(1:nn))
292
293 ex(1:nn, 1:nn) = evectors(1:nn, 1:nn)
294
295 call lalg_inverse(nn, evectors, 'dir')
296
297 do ii = 1, nn
298 evectors(1:nn, ii) = zevalues(1:nn)*evectors(1:nn, ii)
299 end do
300
301 ex(:, :) = matmul(ex(:, :), evectors(:, :))
302
303 safe_deallocate_a(zevalues)
304 end if
305
306 safe_deallocate_a(evectors)
307
308 pop_sub(zlalg_exp)
309 end subroutine zlalg_exp
310
311
328 subroutine zlalg_phi(nn, pp, aa, ex, hermitian)
329 integer, intent(in) :: nn
330 complex(real64), intent(in) :: pp
331 complex(real64), contiguous, intent(in) :: aa(:, :)
332 complex(real64), contiguous, intent(inout) :: ex(:, :)
333 logical, intent(in) :: hermitian
334
335 complex(real64), allocatable :: evectors(:, :), zevalues(:)
336 real(real64), allocatable :: evalues(:)
337
338 integer :: ii
339
340 push_sub(zlalg_phi)
341
342 safe_allocate(evectors(1:nn, 1:nn))
343
344 if (hermitian) then
345 safe_allocate(evalues(1:nn))
346 safe_allocate(zevalues(1:nn))
347
348 evectors(:, :) = aa(:, :)
349
350 call lalg_eigensolve(nn, evectors, evalues)
351
352 do ii = 1, nn
353 zevalues(ii) = (exp(pp*evalues(ii)) - m_z1) / (pp*evalues(ii))
354 end do
355
356 do ii = 1, nn
357 ex(1:nn, ii) = zevalues(1:nn)*conjg(evectors(ii, 1:nn))
358 end do
359
360 ex(:, :) = matmul(evectors(:, :), ex(:, :))
361
362 safe_deallocate_a(evalues)
363 safe_deallocate_a(zevalues)
364 else
365 safe_allocate(zevalues(1:nn))
366
367 evectors(:, :) = aa(:, :)
368
369 call lalg_eigensolve_nonh(nn, evectors, zevalues)
370
371 do ii = 1, nn
372 zevalues(ii) = (exp(pp*zevalues(ii)) - m_z1) / (pp*zevalues(ii))
373 end do
374
375 ex(:, :) = evectors(:, :)
376
377 call lalg_inverse(nn, evectors, 'dir')
378
379 do ii = 1, nn
380 evectors(1:nn, ii) = zevalues(1:nn)*evectors(1:nn, ii)
381 end do
382
383 ex(:, :) = matmul(ex(:, :), evectors(:, :))
384
385 safe_deallocate_a(zevalues)
386 end if
387
388 pop_sub(zlalg_phi)
389 end subroutine zlalg_phi
390
391 complex(real64) function lalg_zdni(eigenvec, alpha, beta)
392 integer, intent(in) :: alpha, beta
393 complex(real64), intent(in) :: eigenvec(2)
394 lalg_zdni = conjg(eigenvec(alpha)) * eigenvec(beta)
395 end function lalg_zdni
396
397 complex(real64) function lalg_zduialpha(eigenvec, mmatrix, alpha, gamma, delta)
398 integer, intent(in) :: alpha, gamma, delta
399 complex(real64),intent(in) :: eigenvec(2), mmatrix(2, 2)
400 lalg_zduialpha = mmatrix(alpha, gamma) * eigenvec(delta)
401 end function lalg_zduialpha
402
403 complex(real64) function lalg_zd2ni(eigenvec, mmatrix, alpha, beta, gamma, delta)
404 integer, intent(in) :: alpha, beta, gamma, delta
405 complex(real64), intent(in) :: eigenvec(2), mmatrix(2, 2)
406 lalg_zd2ni = conjg(mmatrix(alpha, delta) * eigenvec(gamma)) * eigenvec(beta) + &
407 conjg(eigenvec(alpha)) * mmatrix(beta, gamma) * eigenvec(delta)
408 end function lalg_zd2ni
409
410 ! ---------------------------------------------------------
415 pure real(real64) function pseudoinverse_default_tolerance(m, n, sg_values) result(tol)
416 integer, intent(in) :: m, n
417 real(real64), contiguous, intent(in) :: sg_values(:)
418 tol = m_epsilon * m * n * maxval(sg_values)
420
421
427 function lalg_remove_rotation(n, A) result(P)
428 integer, intent(in) :: n
429 real(real64), intent(in) :: a(1:n, 1:n)
430 real(real64) :: p(1:n, 1:n)
431
432 real(real64) :: ata(1:n, 1:n)
433
434 push_sub(lalg_remove_rotation)
435
436 ata = matmul(transpose(a), a)
437 call lalg_matrix_function(n, m_one, ata, p, square_root, .true.)
438
439 pop_sub(lalg_remove_rotation)
440 end function lalg_remove_rotation
441
442 ! ---------------------------------------------------------
447 subroutine lalg_tridiagonal_function_first_column(n, t, fun, factor, col, factor2, col2)
448 integer, intent(in) :: n
449 complex(real64), intent(in) :: t(:, :)
450 interface
451 complex(real64) function fun(z)
452 import real64
453 complex(real64), intent(in) :: z
454 end
455 end interface
456 complex(real64), intent(in) :: factor
457 complex(real64), intent(inout) :: col(:)
458 complex(real64), optional, intent(in) :: factor2
459 complex(real64), optional, intent(inout) :: col2(:)
460
461 real(real64), allocatable :: evectors(:, :), evalues(:)
462 integer :: i
465
466 safe_allocate(evectors(1:n, 1:n))
467 safe_allocate(evalues(1:n))
468
469 ! The eigensolver reads only the diagonal and the superdiagonal
470 do i = 1, n
471 evectors(i, i) = real(t(i, i), real64)
472 if (i > 1) evectors(i - 1, i) = real(t(i - 1, i), real64)
473 end do
474 call lalg_eigensolve_tridiagonal(n, evectors, evalues)
476 col(1:n) = matmul(evectors, [(fun(factor*evalues(i))*evectors(1, i), i = 1, n)])
477 if (present(col2)) then
478 col2(1:n) = matmul(evectors, [(fun(factor2*evalues(i))*evectors(1, i), i = 1, n)])
479 end if
480
481 safe_deallocate_a(evectors)
482 safe_deallocate_a(evalues)
483
486
487 ! ---------------------------------------------------------
492 subroutine lalg_hessenberg_function_first_column(n, h, fun, factor, col, factor2, col2)
493 integer, intent(in) :: n
494 complex(real64), intent(in) :: h(:, :)
495 interface
496 complex(real64) function fun(z)
497 import real64
498 complex(real64), intent(in) :: z
499 end
500 end interface
501 complex(real64), intent(in) :: factor
502 complex(real64), intent(inout) :: col(:)
503 complex(real64), optional, intent(in) :: factor2
504 complex(real64), optional, intent(inout) :: col2(:)
505
506 complex(real64), allocatable :: evectors(:, :), evalues(:), rhs(:, :), y(:, :)
507 real(real64), parameter :: tol_defective = 1e-12
508 real(real64) :: tol
509 integer :: i
510
512
513 safe_allocate(evectors(1:n, 1:n))
514 safe_allocate(evalues(1:n))
515 safe_allocate(rhs(1:n, 1:1))
516 safe_allocate(y(1:n, 1:1))
517
518 evectors(1:n, 1:n) = h(1:n, 1:n)
519 call lalg_eigensolve_nonh(n, evectors, evalues)
520
521 ! Same defectiveness warning as zlalg_matrix_function
522 tol = tol_defective
523 if (maxval(abs(evalues)) > tol_defective) tol = tol * maxval(abs(evalues))
524 do i = 1, n-1
525 if (abs(evalues(i+1) - evalues(i)) < tol) then
526 message(1) = "Potential defective case detected (repeated eigenvalues)."
527 write(message(2), '(a,i3,a)') "Eigenvalue ", i, " is repeated within tolerance."
528 call messages_warning(2)
529 end if
530 end do
531
532 ! y = Z^-1 e_1; gesvx without equilibration leaves Z unchanged
533 rhs = m_z0
534 rhs(1, 1) = m_z1
535 call lalg_linsyssolve(n, 1, evectors, rhs, y)
536
537 col(1:n) = matmul(evectors, [(fun(factor*evalues(i))*y(i, 1), i = 1, n)])
538 if (present(col2)) then
539 col2(1:n) = matmul(evectors, [(fun(factor2*evalues(i))*y(i, 1), i = 1, n)])
540 end if
541
542 safe_deallocate_a(evectors)
543 safe_deallocate_a(evalues)
544 safe_deallocate_a(rhs)
545 safe_deallocate_a(y)
546
549
550#include "undef.F90"
551#include "complex.F90"
552#include "lalg_adv_lapack_inc.F90"
553
554#include "undef.F90"
555#include "real.F90"
556#include "lalg_adv_lapack_inc.F90"
557
558end module lalg_adv_oct_m
559
560!! Local Variables:
561!! mode: f90
562!! coding: utf-8
563!! End:
Note that lalg_determinant and lalg_inverse are just wrappers over the same routine.
Definition: lalg_adv.F90:181
double exp(double __x) __attribute__((__nothrow__
This module contains interfaces for BLACS routines Interfaces are from http://www....
Definition: blacs.F90:25
This module provides the BLACS processor grid.
This module contains interfaces for BLAS routines You should not use these routines directly....
Definition: blas.F90:97
complex(real64) function, public lalg_zd2ni(eigenvec, mmatrix, alpha, beta, gamma, delta)
Definition: lalg_adv.F90:476
integer function zmatrix_rank_svd(a, preserve_mat, tol)
Compute the rank of the matrix A using SVD.
Definition: lalg_adv.F90:1978
subroutine zlowest_geneigensolve(k, n, a, b, e, v, preserve_mat, bof, err_code)
Computes the k lowest eigenvalues and the eigenvectors of a real symmetric or complex Hermitian gener...
Definition: lalg_adv.F90:1133
complex(real64) function zdeterminant(n, a, preserve_mat)
Invert a real symmetric or complex Hermitian square matrix a.
Definition: lalg_adv.F90:1497
subroutine zeigensolve_nonh(n, a, e, err_code, side, sort_eigenvectors)
Computes all the eigenvalues and the right (left) eigenvectors of a real or complex (non-Hermitian) e...
Definition: lalg_adv.F90:1012
subroutine zlinsyssolve(n, nrhs, a, b, x)
compute the solution to a real system of linear equations A*X = B, where A is an N-by-N matrix and X ...
Definition: lalg_adv.F90:1651
subroutine, public zlalg_exp(nn, pp, aa, ex, hermitian)
Definition: lalg_adv.F90:323
pure real(real64) function, public pseudoinverse_default_tolerance(m, n, sg_values)
Computes the default Moore-Penrose pseudoinverse tolerance for zeroing.
Definition: lalg_adv.F90:488
subroutine deigensolve_parallel(n, a, e, bof, err_code)
Computes all the eigenvalues and the eigenvectors of a real symmetric or complex Hermitian eigenprobl...
Definition: lalg_adv.F90:3830
subroutine dgeneigensolve(n, a, b, e, preserve_mat, bof, err_code)
Computes all the eigenvalues and the eigenvectors of a real symmetric or complex Hermitian generalize...
Definition: lalg_adv.F90:2515
subroutine zlalg_pseudo_inverse(a, threshold)
Invert a matrix with the Moore-Penrose pseudo-inverse.
Definition: lalg_adv.F90:1912
subroutine zeigensolve(n, a, e, bof, err_code)
Computes all eigenvalues and eigenvectors of a real symmetric or hermitian square matrix A.
Definition: lalg_adv.F90:1253
subroutine dsingular_value_decomp(m, n, a, u, vt, sg_values, preserve_mat)
Computes the singular value decomposition of a real M x N matrix a.
Definition: lalg_adv.F90:3448
subroutine deigensolve_nonh(n, a, e, err_code, side, sort_eigenvectors)
Computes all the eigenvalues and the right (left) eigenvectors of a real or complex (non-Hermitian) e...
Definition: lalg_adv.F90:2712
subroutine deigensolve_tridiagonal(n, a, e, bof, err_code)
Computes all eigenvalues and eigenvectors of a real symmetric tridiagonal matrix. For the Hermitian c...
Definition: lalg_adv.F90:3025
subroutine zinverse(n, a, method, det, threshold, uplo)
An interface to different method to invert a matrix.
Definition: lalg_adv.F90:2167
subroutine dqr_factorization(A, jpvt, tau, info, bof)
Compute a QR factorization with column pivoting of matrix A: A*P = Q*R.
Definition: lalg_adv.F90:2634
real(real64) function sfmin()
Auxiliary function.
Definition: lalg_adv.F90:238
subroutine dlinsyssolve(n, nrhs, a, b, x)
compute the solution to a real system of linear equations A*X = B, where A is an N-by-N matrix and X ...
Definition: lalg_adv.F90:3348
subroutine zsingular_value_decomp(m, n, a, u, vt, sg_values, preserve_mat)
Computes the singular value decomposition of a real M x N matrix a.
Definition: lalg_adv.F90:1751
subroutine dcholesky(n, a, bof, err_code)
Compute the Cholesky decomposition of real symmetric or complex Hermitian positive definite matrix a,...
Definition: lalg_adv.F90:2397
subroutine, public lalg_hessenberg_function_first_column(n, h, fun, factor, col, factor2, col2)
First column of fun(factor*H) for a diagonalizable complex upper Hessenberg matrix H.
Definition: lalg_adv.F90:565
subroutine dlalg_matrix_function(n, factor, a, fun_a, fun, hermitian, tridiagonal)
This routine calculates a function of a matrix by using an eigenvalue decomposition.
Definition: lalg_adv.F90:3901
subroutine deigensolve(n, a, e, bof, err_code)
Computes all eigenvalues and eigenvectors of a real symmetric or hermitian square matrix A.
Definition: lalg_adv.F90:2954
subroutine dcholesky_pivoted(A, piv, rank, tol, work, UL, bof, info)
Compute the Cholesky factorization with complete pivoting of a real symmetric or complex Hermitian po...
Definition: lalg_adv.F90:2453
subroutine zeigensolve_tridiagonal(n, a, e, bof, err_code)
Computes all eigenvalues and eigenvectors of a real symmetric tridiagonal matrix. For the Hermitian c...
Definition: lalg_adv.F90:1326
subroutine zlowest_eigensolve(k, n, a, e, v, preserve_mat)
Computes the k lowest eigenvalues and the eigenvectors of a standard symmetric-definite eigenproblem,...
Definition: lalg_adv.F90:1405
complex(real64) function, public lalg_zduialpha(eigenvec, mmatrix, alpha, gamma, delta)
Definition: lalg_adv.F90:470
subroutine zgeneigensolve(n, a, b, e, preserve_mat, bof, err_code)
Computes all the eigenvalues and the eigenvectors of a real symmetric or complex Hermitian generalize...
Definition: lalg_adv.F90:811
subroutine dleast_squares_vec(nn, aa, bb, xx, preserve_mat)
Definition: lalg_adv.F90:3756
subroutine dlowest_geneigensolve(k, n, a, b, e, v, preserve_mat, bof, err_code)
Computes the k lowest eigenvalues and the eigenvectors of a real symmetric or complex Hermitian gener...
Definition: lalg_adv.F90:2833
subroutine zcholesky(n, a, bof, err_code)
Compute the Cholesky decomposition of real symmetric or complex Hermitian positive definite matrix a,...
Definition: lalg_adv.F90:693
complex(real64) function, public lalg_zdni(eigenvec, alpha, beta)
Definition: lalg_adv.F90:464
subroutine zleast_squares_vec(nn, aa, bb, xx, preserve_mat)
Definition: lalg_adv.F90:2067
real(real64) function, dimension(1:n, 1:n), public lalg_remove_rotation(n, A)
Remove rotation from affine transformation A by computing the polar decomposition and discarding the ...
Definition: lalg_adv.F90:500
subroutine lalg_zgeev(jobvl, jobvr, n, a, lda, w, vl, ldvl, vr, ldvr, work, lwork, rwork, info)
Definition: lalg_adv.F90:289
subroutine, public zlalg_matrix_function(n, factor, a, fun_a, fun, hermitian, tridiagonal)
This routine calculates a function of a matrix by using an eigenvalue decomposition.
Definition: lalg_adv.F90:2215
subroutine zqr_factorization(A, jpvt, tau, info, bof)
Compute a QR factorization with column pivoting of matrix A: A*P = Q*R.
Definition: lalg_adv.F90:934
integer function dmatrix_rank_svd(a, preserve_mat, tol)
Compute the rank of the matrix A using SVD.
Definition: lalg_adv.F90:3667
subroutine dinverse(n, a, method, det, threshold, uplo)
An interface to different method to invert a matrix.
Definition: lalg_adv.F90:3853
subroutine zeigensolve_parallel(n, a, e, bof, err_code)
Computes all the eigenvalues and the eigenvectors of a real symmetric or complex Hermitian eigenprobl...
Definition: lalg_adv.F90:2144
real(real64) function ddeterminant(n, a, preserve_mat)
Invert a real symmetric or complex Hermitian square matrix a.
Definition: lalg_adv.F90:3194
subroutine lalg_dgeev(jobvl, jobvr, n, a, lda, w, vl, ldvl, vr, ldvr, work, lwork, rwork, info)
Definition: lalg_adv.F90:250
subroutine, public lalg_tridiagonal_function_first_column(n, t, fun, factor, col, factor2, col2)
First column of fun(factor*T) for a real symmetric tridiagonal matrix T.
Definition: lalg_adv.F90:520
subroutine dlowest_eigensolve(k, n, a, e, v, preserve_mat)
Computes the k lowest eigenvalues and the eigenvectors of a standard symmetric-definite eigenproblem,...
Definition: lalg_adv.F90:3104
subroutine dsvd_inverse(m, n, a, threshold)
Computes the (pseudo-)inverse of a square N x N matrix, a, using the SVD decomposition....
Definition: lalg_adv.F90:3539
subroutine, public zlalg_phi(nn, pp, aa, ex, hermitian)
Definition: lalg_adv.F90:401
subroutine zcholesky_pivoted(A, piv, rank, tol, work, UL, bof, info)
Compute the Cholesky factorization with complete pivoting of a real symmetric or complex Hermitian po...
Definition: lalg_adv.F90:749
subroutine dlalg_pseudo_inverse(a, threshold)
Invert a matrix with the Moore-Penrose pseudo-inverse.
Definition: lalg_adv.F90:3601
subroutine zsvd_inverse(m, n, a, threshold)
Computes the (pseudo-)inverse of a square N x N matrix, a, using the SVD decomposition....
Definition: lalg_adv.F90:1850
This module contains interfaces for LAPACK routines.
Definition: lapack.F90:97
This module is intended to contain "only mathematical" functions and procedures.
Definition: math.F90:94
/* To use the profiling module, call profiling_in and profiling_out with the label of the region as a...
Definition: profiling.F90:122
This module contains interfaces for ScaLAPACK routines Interfaces are from http://www....
Definition: scalapack.F90:110
This module is intended to contain "only mathematical" functions and procedures.
Definition: sort.F90:96
This module is intended to contain simple general-purpose utility functions and procedures.
Definition: utils.F90:99
int true(void)