! Signatures for f2py-wrappers of FORTRAN LAPACK Symmetric/Hermitian Matrix functions. ! subroutine syev(compute_v,lower,n,w,a,lda,work,lwork,info) ! w,v,info = syev(a,compute_v=1,lower=0,lwork=3*n-1,overwrite_a=0) ! Compute all eigenvalues and, optionally, eigenvectors of a ! real symmetric matrix A. ! ! Performance tip: ! If compute_v=0 then set also overwrite_a=1. callstatement (*f2py_func)((compute_v?"V":"N"),(lower?"L":"U"),&n,a,&lda,w,work,&lwork,&info) callprotoargument char*,char*,F_INT*,*,F_INT*,*,*,F_INT*,F_INT* integer optional,intent(in):: compute_v = 1 check(compute_v==1||compute_v==0) compute_v integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 integer intent(hide),depend(a):: n = shape(a,0) integer intent(hide),depend(a):: lda = MAX(1,shape(a,0)) dimension(n,n),check(shape(a,0)==shape(a,1)) :: a intent(in,copy,out,out=v) :: a dimension(n),intent(out),depend(n) :: w integer optional,intent(in),depend(n) :: lwork=max(3*n-1,1) check(lwork>=3*n-1) :: lwork dimension(lwork),intent(hide),depend(lwork) :: work integer intent(out) :: info end subroutine syev subroutine syev_lwork(lower,n,w,a,lda,work,lwork,info) ! LWORK routines for syev fortranname syev callstatement (*f2py_func)("N",(lower?"L":"U"),&n,&a,&lda,&w,&work,&lwork,&info) callprotoargument char*,char*,F_INT*,*,F_INT*,*,*,F_INT*,F_INT* integer intent(in):: n integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 integer intent(hide),depend(n):: lda = MAX(1, n) intent(hide):: a intent(hide):: w integer intent(hide):: lwork = -1 intent(out):: work integer intent(out):: info end subroutine syev_lwork subroutine heev(compute_v,lower,n,w,a,lda,work,lwork,rwork,info) ! w,v,info = syev(a,compute_v=1,lower=0,lwork=3*n-1,overwrite_a=0) ! Compute all eigenvalues and, optionally, eigenvectors of a ! complex Hermitian matrix A. ! ! Warning: ! If compute_v=0 and overwrite_a=1, the contents of a is destroyed. callstatement (*f2py_func)((compute_v?"V":"N"),(lower?"L":"U"),&n,a,&lda,w,work,&lwork,rwork,&info) callprotoargument char*,char*,F_INT*,*,F_INT*,*,*,F_INT*,*,F_INT* integer optional,intent(in),check(compute_v==1||compute_v==0) :: compute_v = 1 integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 integer intent(hide),depend(a):: n = shape(a,0) integer intent(hide),depend(a):: lda = MAX(1,shape(a,0)) dimension(n,n),check(shape(a,0)==shape(a,1)) :: a intent(in,copy,out,out=v) :: a dimension(n),intent(out),depend(n) :: w integer optional,intent(in),depend(n) :: lwork=max(2*n-1,1) check(lwork>=2*n-1) :: lwork dimension(lwork),intent(hide),depend(lwork) :: work dimension(3*n-1),intent(hide),depend(n) :: rwork integer intent(out) :: info end subroutine heev subroutine heev_lwork(lower,n,w,a,lda,work,lwork,rwork,info) ! LWORK routines for heev fortranname heev callstatement (*f2py_func)("N",(lower?"L":"U"),&n,&a,&lda,&w,&work,&lwork,&rwork,&info) callprotoargument char*,char*,F_INT*,*,F_INT*,*,*,F_INT*,*,F_INT* integer intent(in):: n integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 integer intent(hide),depend(n):: lda = MAX(1, n) intent(hide):: a intent(hide):: w intent(hide):: rwork integer intent(hide):: lwork = -1 intent(out):: work integer intent(out):: info end subroutine heev_lwork subroutine syevd(compute_v,lower,n,w,a,lda,work,lwork,iwork,liwork,info) ! w,v,info = syevd(a,compute_v=1,lower=0,lwork=min_lwork,overwrite_a=0) ! Compute all eigenvalues and, optionally, eigenvectors of a ! real symmetric matrix A using D&C. ! ! Performance tip: ! If compute_v=0 then set also overwrite_a=1. callstatement (*f2py_func)((compute_v?"V":"N"),(lower?"L":"U"),&n,a,&lda,w,work,&lwork,iwork,&liwork,&info) callprotoargument char*,char*,F_INT*,*,F_INT*,*,*,F_INT*,F_INT*,F_INT*,F_INT* integer optional,intent(in),check(compute_v==1||compute_v==0) :: compute_v = 1 integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 integer intent(hide),depend(a):: n = shape(a,0) dimension(n,n),check(shape(a,0)==shape(a,1)) :: a intent(in,copy,out,out=v) :: a integer intent(hide),depend(n) :: lda = MAX(1,n) dimension(n),intent(out),depend(n) :: w integer optional,intent(in),depend(n,compute_v) :: lwork=max((compute_v?1+6*n+2*n*n:2*n+1),1) check(lwork>=(compute_v?1+6*n+2*n*n:2*n+1)) :: lwork dimension(lwork),intent(hide,cache),depend(lwork) :: work integer optional,intent(in),depend(n,compute_v) :: liwork = (compute_v?3+5*n:1) integer dimension(liwork),intent(hide,cache),depend(liwork) :: iwork integer intent(out) :: info end subroutine syevd subroutine syevd_lwork(compute_v,lower,n,w,a,lda,work,lwork,iwork,liwork,info) ! LWORK routines for syevd fortranname syevd callstatement (*f2py_func)((compute_v?"V":"N"),(lower?"L":"U"),&n,&a,&lda,&w,&work,&lwork,&iwork,&liwork,&info) callprotoargument char*,char*,F_INT*,*,F_INT*,*,*,F_INT*,F_INT*,F_INT*,F_INT* integer intent(in):: n integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 integer optional,intent(in),check(compute_v==0||compute_v==1) :: compute_v = 1 integer intent(hide):: lda = MAX(1,n) intent(hide):: a intent(hide):: w integer intent(hide):: lwork = -1 integer intent(hide):: liwork = -1 intent(out):: work integer intent(out):: iwork integer intent(out):: info end subroutine syevd_lwork subroutine heevd(compute_v,lower,n,w,a,lda,work,lwork,iwork,liwork,rwork,lrwork,info) ! w,v,info = heevd(a,compute_v=1,lower=0,lwork=min_lwork,overwrite_a=0) ! Compute all eigenvalues and, optionally, eigenvectors of a ! complex Hermitian matrix A using D&C. ! ! Warning: ! If compute_v=0 and overwrite_a=1, the contents of a is destroyed. callstatement (*f2py_func)((compute_v?"V":"N"),(lower?"L":"U"),&n,a,&lda,w,work,&lwork,rwork,&lrwork,iwork,&liwork,&info) callprotoargument char*,char*,F_INT*,*,F_INT*,*,*,F_INT*,*,F_INT*,F_INT*,F_INT*,F_INT* integer optional,intent(in):: compute_v = 1 check(compute_v==1||compute_v==0) compute_v integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 integer intent(hide),depend(a):: n = shape(a,0) dimension(n,n),check(shape(a,0)==shape(a,1)) :: a intent(in,copy,out,out=v) :: a integer intent(hide),depend(n) :: lda = MAX(1,n) dimension(n),intent(out),depend(n) :: w integer optional,intent(in),depend(n,compute_v) :: lwork=max((compute_v?2*n+n*n:n+1),1) check(lwork>=(compute_v?2*n+n*n:n+1)) :: lwork dimension(lwork),intent(hide,cache),depend(lwork) :: work integer optional,intent(in),depend(n,compute_v) :: liwork = (compute_v?3+5*n:1) integer dimension(liwork),intent(hide,cache),depend(liwork) :: iwork integer optional,intent(in),depend(n,compute_v) :: lrwork = (compute_v?1+5*n+2*n*n:n) dimension(lrwork),intent(hide,cache),depend(n,lrwork) :: rwork integer intent(out) :: info end subroutine heevd subroutine heevd_lwork(compute_v,lower,n,w,a,lda,work,lwork,iwork,liwork,rwork,lrwork,info) ! LWORK routines for heevd fortranname heevd callstatement (*f2py_func)((compute_v?"V":"N"),(lower?"L":"U"),&n,&a,&lda,&w,&work,&lwork,&rwork,&lrwork,&iwork,&liwork,&info) callprotoargument char*,char*,F_INT*,*,F_INT*,*,*,F_INT*,*,F_INT*,F_INT*,F_INT*,F_INT* integer intent(in):: n integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 integer optional,intent(in),check(compute_v==0||compute_v==1) :: compute_v = 1 integer intent(hide):: lda=MAX(1,n) intent(hide):: a intent(hide):: w integer intent(hide):: lwork=-1 integer intent(hide):: liwork=-1 integer intent(hide):: lrwork=-1 intent(out):: work intent(out):: rwork integer intent(out):: iwork integer intent(out):: info end subroutine heevd_lwork subroutine sytf2(lower,n,a,lda,ipiv,info) ! Compute the factorization of a symmetric matrix such that ! A = L * D * L^T if lower = 1 ! A = U * D * U^T if lower = 0 callstatement (*f2py_func)((lower?"L":"U"),&n,a,&lda,ipiv,&info) callprotoargument char*,F_INT*,*,F_INT*,F_INT*,F_INT* integer optional,intent(in),check(lower==0||lower==1):: lower = 0 integer depend(a),intent(hide):: n = shape(a,0) dimension(n,n),intent(in,out,copy,out=ldu):: a integer depend(a),intent(hide):: lda = max(shape(a,0),1) integer dimension(n),depend(n),intent(out):: ipiv integer intent(out):: info end subroutinesytf2 subroutine sygst(n,a,lda,b,ldb,info,itype,lower) ! c, info = sygst(a,b) ! Transforms the generalized symmetric eigenvalue problem to standard. ! A = inv(U^T) * A * inv(U), if itype == 1 ! A = U^T * A * U or L^T * A * L, if itype == 2 or 3, respectively ! B must contain the factorized U and L from potrf callstatement (*f2py_func)(&itype,(lower?"L":"U"),&n,a,&lda,b,&ldb,&info) callprotoargument F_INT*,char*,F_INT*,*,F_INT*,*,F_INT*,F_INT* integer optional,intent(in),check(itype==1||itype==2||itype==3):: itype = 1 integer optional,intent(in),check(lower==0||lower==1):: lower = 0 integer depend(a),intent(hide):: n = shape(a,0) dimension(n,n),intent(in,out,copy,out=c):: a integer depend(a),intent(hide):: lda = max(shape(a,0),1) dimension(n,n),intent(in):: b integer depend(b),intent(hide):: ldb = max(shape(b,0),1) integer intent(out):: info end subroutine sygst subroutine sytrf(lower,n,a,lda,ipiv,work,lwork,info) ! Compute the factorization of a symmetric matrix such that ! A = L * D * L^T if lower = 1 ! A = U * D * U^T if lower = 0 ! This is similar to ?SYTF2 but uses BLAS3 blocked calls callstatement (*f2py_func)((lower?"L":"U"),&n,a,&lda,ipiv,work,&lwork,&info) callprotoargument char*,F_INT*,*,F_INT*,F_INT*,*,F_INT*,F_INT* integer optional,intent(in),check(lower==0||lower==1):: lower = 0 integer depend(a),intent(hide):: n = shape(a,0) dimension(n,n),intent(in,out,copy,out=ldu):: a integer depend(a),intent(hide):: lda = max(shape(a,0),1) integer dimension(n),depend(n),intent(out):: ipiv integer optional,intent(in),depend(n),check(lwork>=n||lwork==-1):: lwork = max(n,1) depend(lwork),dimension(MAX(lwork,1)),intent(hide,cache):: work integer intent(out):: info end subroutine sytrf subroutine sytrf_lwork(lower,n,a,lda,ipiv,work,lwork,info) ! lwork computation for ?SYTRF fortranname sytrf callstatement (*f2py_func)((lower?"L":"U"),&n,&a,&lda,&ipiv,&work,&lwork,&info) callprotoargument char*,F_INT*,*,F_INT*,F_INT*,*,F_INT*,F_INT* integer intent(in):: n integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 intent(hide):: a integer depend(n),intent(hide):: lda = max(n,1) integer intent(hide):: ipiv integer intent(hide):: lwork = -1 intent(out):: work integer intent(out):: info end subroutine sytrf_lwork subroutine sysv(n,nrhs,a,lda,ipiv,b,ldb,work,lwork,info,lower) ! Solve A * X = B for symmetric A matrix callstatement (*f2py_func)((lower?"L":"U"),&n,&nrhs,a,&lda,ipiv,b,&ldb,work,&lwork,&info) callprotoargument char*,F_INT*,F_INT*,*,F_INT*,F_INT*,*,F_INT*,*,F_INT*,F_INT* integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 integer depend(a),intent(hide):: n = shape(a,0) integer depend(b),intent(hide):: nrhs = shape(b,1) dimension(n,n),check(shape(a,0)==shape(a,1)),intent(in,out,copy,out=udut):: a integer depend(a),intent(hide):: lda = shape(a,0) integer dimension(n),depend(n),intent(out):: ipiv dimension(n,nrhs),check(shape(b,0)==n),depend(n),intent(in,out,copy,out=x):: b integer depend(b),intent(hide):: ldb = shape(b,0) integer optional,intent(in),depend(n),check(lwork>=1||lwork==-1):: lwork = max(n,1) depend(lwork),dimension(MAX(lwork,1)),intent(hide,cache):: work integer intent(out):: info end subroutine sysv subroutine sysv_lwork(n,nrhs,a,lda,ipiv,b,ldb,work,lwork,info,lower) ! lwork computation for ?SYSV fortranname sysv callstatement (*f2py_func)((lower?"L":"U"),&n,&nrhs,&a,&lda,&ipiv,&b,&ldb,&work,&lwork,&info) callprotoargument char*,F_INT*,F_INT*,*,F_INT*,F_INT*,*,F_INT*,*,F_INT*,F_INT* integer intent(in):: n integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 integer intent(hide):: nrhs = 1 intent(hide):: a integer depend(n),intent(hide):: lda = n integer intent(hide):: ipiv intent(hide):: b integer depend(n),intent(hide):: ldb = n integer intent(hide):: lwork = -1 intent(out):: work integer intent(out):: info end subroutine sysv_lwork subroutine sysvx(n,nrhs,a,lda,af,ldaf,ipiv,b,ldb,x,ldx,rcond,ferr,berr,work,lwork,irwork,info,factored,lower) ! Solve A * X = B for symmetric A matrix ! The expert driver of ?SYSV with condition number, backward,forward error estimates and iterative refinement ! The (c,z) versions assume only symmetric complex matrices. For Hermitian matrices, routine (c,z)HESVX is used threadsafe callstatement (*f2py_func)((factored?"F":"N"),(lower?"L":"U"),&n,&nrhs,a,&lda,af,&ldaf,ipiv,b,&ldb,x,&ldx,&rcond,ferr,berr,work,&lwork,irwork,&info) callprotoargument char*,char*,F_INT*,F_INT*,*,F_INT*,*,F_INT*,F_INT*,*,F_INT*,*,F_INT*,*,*,*,*,F_INT*,*,F_INT* integer optional,intent(in),check(factored==0||factored==1) :: factored = 0 integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 integer depend(a),intent(hide):: n = shape(a,0) integer depend(b),intent(hide):: nrhs = shape(b,1) dimension(n,n),check(shape(a,0)==shape(a,1)),intent(in,copy,out,out=a_s):: a integer depend(a),intent(hide):: lda = shape(a,0) optional,dimension(n,n),depend(n),intent(in,out,out=udut):: af integer optional,depend(af),intent(hide):: ldaf = shape(af,0) integer optional,dimension(n),depend(n),intent(in,out):: ipiv depend(n),dimension(n,nrhs),intent(in,copy,out,out=b_s):: b integer depend(b),intent(hide):: ldb = shape(b,0) dimension(n,nrhs),intent(out):: x integer depend(b),intent(hide):: ldx = n intent(out):: rcond intent(out),dimension(nrhs),depend(nrhs):: ferr intent(out),dimension(nrhs),depend(nrhs):: berr integer optional,intent(in),check(lwork>=<3*n,3*n,2*n,2*n>||lwork==-1):: lwork = max(3*n,1) dimension(MAX(lwork,1)),intent(hide,cache),depend(lwork) :: work intent(hide,cache),dimension(n),depend(n) :: irwork integer intent(out):: info end subroutine sysvx subroutine sysvx_lwork(n,nrhs,a,lda,af,ldaf,ipiv,b,ldb,x,ldx,rcond,ferr,berr,work,lwork,irwork,info,factored,lower) ! lwork computation for ?SYSVX fortranname sysvx callstatement (*f2py_func)((factored?"F":"N"),(lower?"L":"U"),&n,&nrhs,&a,&lda,&af,&ldaf,&ipiv,&b,&ldb,&x,&ldx,&rcond,&ferr,&berr,&work,&lwork,&irwork,&info) callprotoargument char*,char*,F_INT*,F_INT*,*,F_INT*,*,F_INT*,F_INT*,*,F_INT*,*,F_INT*,*,*,*,*,F_INT*,*,F_INT* integer intent(in):: n integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 integer intent(hide) :: factored = 0 integer intent(hide):: nrhs = 1 intent(hide):: a integer depend(n),intent(hide):: lda = n intent(hide):: af integer depend(n),intent(hide):: ldaf = n integer intent(hide):: ipiv intent(hide):: b integer depend(n),intent(hide):: ldb = n intent(hide):: x integer depend(n),intent(hide):: ldx = n intent(hide):: rcond intent(hide):: ferr intent(hide):: berr integer intent(hide):: lwork = -1 intent(hide):: irwork intent(out) :: work integer intent(out):: info end subroutine sysvx_lwork subroutine sycon(n,a,lda,ipiv,anorm,rcond,work,iwork,info,lower) ! Estimates the reciprocal of the condition number (in the ! 1-norm) of a real symmetric matrix A using the factorization ! A = U*D*U**T or A = L*D*L**T computed by (S/D)SYTRF. ! ! An estimate is obtained for norm(inv(A)), and the reciprocal of the ! condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))) callstatement (*f2py_func)((lower?"L":"U"),&n,a,&lda,ipiv,&anorm,&rcond,work,iwork,&info) callprotoargument char*,F_INT*,*,F_INT*,F_INT*,*,*,*,F_INT*,F_INT* integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 integer depend(a),intent(hide):: n = shape(a,0) dimension(n,n),check(shape(a,0)==shape(a,1)),intent(in):: a integer intent(hide),depend(a) :: lda = max(shape(a,0),1) integer intent(in),dimension(n),depend(n) :: ipiv intent(in) :: anorm intent(out) :: rcond intent(hide),dimension(2*n),depend(n) :: work integer intent(hide),dimension(n),depend(n) :: iwork integer intent(out) :: info end subroutine sycon subroutine con(n,a,lda,ipiv,anorm,rcond,work,info,lower) ! Estimates the reciprocal of the condition number (in the ! 1-norm) of a complex symmetric matrix A using the factorization ! A = U*D*U**T or A = L*D*L**T computed by (C/Z)SYTRF. ! ! An estimate is obtained for norm(inv(A)), and the reciprocal of the ! condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))) callstatement (*f2py_func)((lower?"L":"U"),&n,a,&lda,ipiv,&anorm,&rcond,work,&info) callprotoargument char*,F_INT*,*,F_INT*,F_INT*,*,*,*,F_INT* integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 integer depend(a),intent(hide):: n = shape(a,0) dimension(n,n),check(shape(a,0)==shape(a,1)),intent(in):: a integer intent(hide),depend(a) :: lda = max(shape(a,0),1) integer intent(in),dimension(n),depend(n) :: ipiv intent(in) :: anorm intent(out) :: rcond intent(hide),dimension(2*n),depend(n) :: work integer intent(out) :: info end subroutine con subroutine syconv(lower,way,n,a,lda,ipiv,e,info) ! ?SYCONV converts A given by ???TRF into L and D and vice-versa. ! Get Non-diag elements of D (returned in workspace) and apply or reverse permutation done in TRF. callstatement (*f2py_func)((lower?"L":"U"),(way?"R":"C"),&n,a,&lda,ipiv,e,&info) callprotoargument char*,char*,F_INT*,*,F_INT*,F_INT*,*,F_INT* integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 integer optional,intent(in),check(way==0||way==1) :: way = 0 integer depend(a),intent(hide):: n = shape(a,0) dimension(n,n),check(shape(a,0)==shape(a,1)),intent(in,out,copy,out=a):: a integer intent(hide),depend(a) :: lda = max(shape(a,0),1) integer intent(in),dimension(n),depend(n) :: ipiv intent(out),dimension(n),depend(n):: e integer intent(out) :: info end subroutine syconv subroutine hegst(n,a,lda,b,ldb,info,itype,lower) ! c, info = hegst(a,b) ! Transforms the generalized Hermitian eigenvalue problem to standard. ! A = inv(U^H) * A * inv(U), if itype == 1 ! A = U^H * A * U or L^H * A * L, if itype == 2 or 3, respectively ! B must contain the factorized U and L from potrf callstatement (*f2py_func)(&itype,(lower?"L":"U"),&n,a,&lda,b,&ldb,&info) callprotoargument F_INT*,char*,F_INT*,*,F_INT*,*,F_INT*,F_INT* integer optional,intent(in),check(itype==1||itype==2||itype==3):: itype = 1 integer optional,intent(in),check(lower==0||lower==1):: lower = 0 integer depend(a),intent(hide):: n = shape(a,0) dimension(n,n),intent(in,out,copy,out=c):: a integer depend(a),intent(hide):: lda = max(shape(a,0),1) dimension(n,n),intent(in):: b integer depend(b),intent(hide):: ldb = max(shape(b,0),1) integer intent(out):: info end subroutine hegst subroutine hetrf(lower,n,a,lda,ipiv,work,lwork,info) ! Compute the factorization of a hermitian matrix such that ! A = L * D * L^T if lower = 1 ! A = U * D * U^T if lower = 0 ! This is similar to ?HETF2 but uses BLAS3 blocked calls callstatement (*f2py_func)((lower?"L":"U"),&n,a,&lda,ipiv,work,&lwork,&info) callprotoargument char*,F_INT*,*,F_INT*,F_INT*,*,F_INT*,F_INT* integer optional,intent(in),check(lower==0||lower==1):: lower = 0 integer depend(a),intent(hide):: n = shape(a,0) dimension(n,n),intent(in,out,copy,out=ldu):: a integer depend(a),intent(hide):: lda = max(shape(a,0),1) integer dimension(n),depend(n),intent(out):: ipiv integer optional,intent(in),depend(n),check(lwork>=n||lwork==-1):: lwork = max(n,1) depend(lwork),dimension(MAX(lwork,1)),intent(hide,cache):: work integer intent(out):: info end subroutine hetrf subroutine hetrf_lwork(lower,n,a,lda,ipiv,work,lwork,info) ! lwork computation for ?HETRF fortranname hetrf callstatement (*f2py_func)((lower?"L":"U"),&n,&a,&lda,&ipiv,&work,&lwork,&info) callprotoargument char*,F_INT*,*,F_INT*,F_INT*,*,F_INT*,F_INT* integer intent(in):: n integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 intent(hide):: a integer depend(n),intent(hide):: lda = max(n,1) integer intent(hide):: ipiv integer intent(hide):: lwork = -1 intent(out):: work integer intent(out):: info end subroutine hetrf_lwork subroutine hesv(n,nrhs,a,lda,ipiv,b,ldb,work,lwork,info,lower) ! Solves A * X = B for X ! A is hermitian. For symmetric A see ?SYSV ! A = U * D * U**H if lower = 0 ! A = L * D * L**H if lower = 1 threadsafe callstatement (*f2py_func)((lower?"L":"U"),&n,&nrhs,a,&lda,ipiv,b,&ldb,work,&lwork,&info) callprotoargument char*,F_INT*,F_INT*,*,F_INT*,F_INT*,*,F_INT*,*,F_INT*,F_INT* integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 integer depend(a),intent(hide):: n = shape(a,0) integer depend(b),intent(hide):: nrhs = shape(b,1) dimension(n,n),check(shape(a,0)==shape(a,1)),intent(in,out,copy,out=uduh):: a integer depend(a),intent(hide):: lda = shape(a,0) integer dimension(n),depend(n),intent(out):: ipiv dimension(n,nrhs),check(shape(b,0)==n),depend(n),intent(in,out,copy,out=x):: b integer depend(b),intent(hide):: ldb = shape(b,0) integer optional,intent(in),depend(n),check(lwork>=1||lwork==-1):: lwork = max(n,1) depend(lwork),dimension(MAX(lwork,1)),intent(hide,cache):: work integer intent(out):: info end subroutine hesv subroutine hesv_lwork(n,nrhs,a,lda,ipiv,b,ldb,work,lwork,info,lower) ! lwork computation for C/ZHESV fortranname hesv callstatement (*f2py_func)((lower?"L":"U"),&n,&nrhs,&a,&lda,&ipiv,&b,&ldb,&work,&lwork,&info) callprotoargument char*,F_INT*,F_INT*,*,F_INT*,F_INT*,*,F_INT*,*,F_INT*,F_INT* integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 integer intent(in):: n integer intent(hide):: nrhs = 1 intent(hide):: a integer intent(hide),depend(n):: lda = n integer intent(hide):: ipiv intent(hide):: b integer intent(hide),depend(n):: ldb = n integer intent(hide):: lwork = -1 intent(out):: work integer intent(out):: info end subroutine hesv_lwork subroutine hesvx(n,nrhs,a,lda,af,ldaf,ipiv,b,ldb,x,ldx,rcond,ferr,berr,work,lwork,rwork,info,factored,lower) ! Solves A * X = B for X ! Expert driver for ?HESV ! A is hermitian. For symmetric A see ?SYSVX ! A = U * D * U**H if lower = 0 ! A = L * D * L**H if lower = 1 threadsafe callstatement (*f2py_func)((factored?"F":"N"),(lower?"L":"U"),&n,&nrhs,a,&lda,af,&ldaf,ipiv,b,&ldb,x,&ldx,&rcond,ferr,berr,work,&lwork,rwork,&info) callprotoargument char*,char*,F_INT*,F_INT*,*,F_INT*,*,F_INT*,F_INT*,*,F_INT*,*,F_INT*,*,*,*,*,F_INT*,*,F_INT* integer optional,intent(in),check(factored==0||factored==1) :: factored = 0 integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 integer depend(a),intent(hide):: n = shape(a,0) integer depend(b),intent(hide):: nrhs = shape(b,1) dimension(n,n),check(shape(a,0)==shape(a,1)),intent(in,copy) :: a integer depend(a),intent(hide):: lda = shape(a,0) optional,dimension(n,n),depend(n),intent(in,out,out=uduh) :: af integer optional,depend(af),intent(hide):: ldaf = shape(af,0) integer optional,depend(n),dimension(n),intent(in,out):: ipiv depend(n),dimension(n,nrhs),intent(in,copy) :: b integer depend(b),intent(hide):: ldb = shape(b,0) depend(n,nrhs),dimension(n,nrhs),intent(out) :: x integer depend(x),intent(hide):: ldx = shape(x,0) intent(out):: rcond intent(out),dimension(nrhs),depend(nrhs):: ferr intent(out),dimension(nrhs),depend(nrhs):: berr dimension(MAX(1,lwork)),depend(lwork),intent(hide,cache):: work integer optional,intent(in),depend(n),check(lwork>=1||lwork==-1):: lwork = max(2*n,1) intent(hide,cache),dimension(n),depend(n) :: rwork integer intent(out):: info end subroutine hesvx subroutine hesvx_lwork(n,nrhs,a,lda,af,ldaf,ipiv,b,ldb,x,ldx,rcond,ferr,berr,work,lwork,rwork,info,factored,lower) ! lwork computation for ?HESVX fortranname hesvx callstatement (*f2py_func)((factored?"F":"N"),(lower?"L":"U"),&n,&nrhs,&a,&lda,&af,&ldaf,&ipiv,&b,&ldb,&x,&ldx,&rcond,&ferr,&berr,&work,&lwork,&rwork,&info) callprotoargument char*,char*,F_INT*,F_INT*,*,F_INT*,*,F_INT*,F_INT*,*,F_INT*,*,F_INT*,*,*,*,*,F_INT*,*,F_INT* integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 integer intent(in):: n integer intent(hide) :: factored = 0 integer depend(b),intent(hide):: nrhs = 1 intent(hide) :: a integer depend(n),intent(hide):: lda = n intent(hide) :: af integer depend(n),intent(hide):: ldaf = n integer intent(hide):: ipiv intent(hide) :: b integer depend(n),intent(hide):: ldb = n intent(hide) :: x integer depend(n),intent(hide):: ldx = n intent(hide):: rcond intent(hide):: ferr intent(hide):: berr integer intent(hide):: lwork = -1 intent(hide):: rwork intent(out):: work integer intent(out):: info end subroutine hesvx_lwork subroutine sytrd(lower,n,a,lda,d,e,tau,work,lwork,info) ! Reduce a real symmetric matrix A to real symmetric ! tridiagonal form T by an orthogonal similarity transformation: ! Q**T * A * Q = T. callstatement (*f2py_func)((lower?"L":"U"),&n,a,&lda,d,e,tau,work,&lwork,&info); callprotoargument char*,F_INT*,*,F_INT*,*,*,*,*,F_INT*,F_INT* integer intent(hide),depend(a) :: lda=MAX(shape(a,0),1) integer intent(hide),depend(a) :: n=shape(a,1) integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 dimension(lda,n),check(shape(a,0)==shape(a,1)),intent(in,out,copy,out=c) :: a dimension(n),intent(out),depend(n) :: d dimension(n-1),intent(out),depend(n) :: e dimension(n-1),intent(out),depend(n) :: tau integer intent(in),optional,depend(n),check(lwork>=1||lwork==-1) :: lwork = MAX(n,1) dimension(lwork),intent(cache,hide),depend(lwork) :: work integer intent(out) :: info end subroutine sytrd subroutine sytrd_lwork(lower,n,a,lda,d,e,tau,work,lwork,info) ! lwork computation for sytrd fortranname sytrd callstatement (*f2py_func)((lower?"L":"U"),&n,&a,&lda,&d,&e,&tau,&work,&lwork,&info); callprotoargument char*,F_INT*,*,F_INT*,*,*,*,*,F_INT*,F_INT* integer intent(in) :: n integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 integer intent(hide),depend(n) :: lda=MAX(n,1) intent(hide) :: a intent(hide) :: d intent(hide) :: e intent(hide) :: tau intent(out) :: work integer intent(hide) :: lwork = -1 integer intent(out) :: info end subroutine sytrd_lwork subroutine hetrd(lower,n,a,lda,d,e,tau,work,lwork,info) ! Reduce a complex hermitian matrix A to real symmetric ! tridiagonal form T by an orthogonal similarity transformation: ! Q**H * A * Q = T. callstatement (*f2py_func)((lower?"L":"U"),&n,a,&lda,d,e,tau,work,&lwork,&info); callprotoargument char*,F_INT*,*,F_INT*,*,*,*,*,F_INT*,F_INT* integer intent(hide),depend(a) :: lda=MAX(shape(a,0),1) integer intent(hide),depend(a) :: n=shape(a,1) integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 dimension(lda,n),check(shape(a,0)==shape(a,1)),intent(in,out,copy,out=c) :: a dimension(n),intent(out),depend(n) :: d dimension(n-1),intent(out),depend(n) :: e dimension(n-1),intent(out),depend(n) :: tau integer intent(in),optional,depend(n),check(lwork>=1||lwork==-1) :: lwork = MAX(n,1) dimension(lwork),intent(cache,hide),depend(lwork) :: work integer intent(out) :: info end subroutine hetrd subroutine hetrd_lwork(lower,n,a,lda,d,e,tau,work,lwork,info) ! lwork computation for hetrd fortranname hetrd callstatement (*f2py_func)((lower?"L":"U"),&n,&a,&lda,&d,&e,&tau,&work,&lwork,&info); callprotoargument char*,F_INT*,*,F_INT*,*,*,*,*,F_INT*,F_INT* integer intent(in) :: n integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 integer intent(hide),depend(n) :: lda=MAX(n,1) intent(hide) :: a intent(hide) :: d intent(hide) :: e intent(hide) :: tau intent(out) :: work integer intent(hide) :: lwork = -1 integer intent(out) :: info end subroutine hetrd_lwork subroutine syevr(compute_v,range,lower,n,a,lda,vl,vu,il,iu,abstol,w,z,m,ldz,isuppz,work,lwork,iwork,liwork,info) ! Standard Symmetric/HermitianEigenvalue Problem ! Real - Single precision / Double precision ! ! if jobz = 'N' there are no eigvecs hence 0x0 'z' returned ! if jobz = 'V' and range = 'A', z is (nxn) ! if jobz = 'V' and range = 'V', z is (nxn) since returned number of eigs is unknown beforehand ! if jobz = 'V' and range = 'I', z is (nx(iu-il+1)) callstatement (*f2py_func)((compute_v?"V":"N"),range,(lower?"L":"U"),&n,a,&lda,&vl,&vu,&il,&iu,&abstol,&m,w,z,&ldz,isuppz,work,&lwork,iwork,&liwork,&info) callprotoargument char*,char*,char*,F_INT*,*,F_INT*,*,*,F_INT*,F_INT*,*,F_INT*,*,*,F_INT*,F_INT*,*,F_INT*,F_INT*,F_INT*,F_INT* intent(in,copy,aligned8),check(shape(a,0)==shape(a,1)),dimension(n,n) :: a integer optional,intent(in),check(compute_v==1||compute_v==0):: compute_v = 1 character optional,intent(in),check(*range=='A'||*range=='V' ||*range=='I') :: range='A' integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 integer optional,intent(in),check(il>=1&&il<=n),depend(n) :: il=1 integer optional,intent(in),check(n>=iu&&iu>=il),depend(n,il) :: iu=n optional,intent(in) :: vl=0.0 optional,intent(in),check(vu>=vl),depend(vl) :: vu=1.0 intent(in) :: abstol=0.0 integer optional,intent(in),depend(n),check(lwork>=max(1,26*n)||lwork==-1) :: lwork=max(26*n,1) integer optional,intent(in),depend(n),check(liwork>=max(1,10*n)||liwork==-1):: liwork= max(1,10*n) integer intent(hide),depend(a) :: n=shape(a,0) integer intent(hide),depend(n) :: lda=max(1,n) integer intent(hide),depend(z) :: ldz=max(1,shape(z,0)) intent(hide),dimension(lwork),depend(lwork) :: work integer intent(hide),dimension(liwork),depend(liwork) :: iwork intent(out),dimension(n),depend(n) :: w intent(out),dimension((compute_v?MAX(0,n):0),(compute_v?((*range=='I')?(iu-il+1):MAX(1,n)):0)),depend(n,compute_v,range,iu,il) :: z integer intent(out) :: m ! Only returned if range=='A' or range=='I' and il, iu = 1, n integer intent(out),dimension((compute_v?(2*((*range=='A')||((*range=='I') && (iu-il+1==n))?n:0)):0)),depend(n,iu,il,compute_v,range) :: isuppz integer intent(out) :: info end subroutine syevr subroutine syevr_lwork(lower,n,a,lda,vl,vu,il,iu,abstol,m,w,z,ldz,isuppz,work,lwork,iwork,liwork,info) ! LWORK routines for (s/d)syevr fortranname syevr callstatement (*f2py_func)("N","A",(lower?"L":"U"),&n,&a,&lda,&vl,&vu,&il,&iu,&abstol,&m,&w,&z,&ldz,&isuppz,&work,&lwork,&iwork,&liwork,&info) callprotoargument char*,char*,char*,F_INT*,*,F_INT*,*,*,F_INT*,F_INT*,*,F_INT*,*,*,F_INT*,F_INT*,*,F_INT*,F_INT*,F_INT*,F_INT* ! Inputs integer intent(in):: n integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 ! Not referenced intent(hide) :: a integer intent(hide),depend(n) :: lda = max(1,n) intent(hide) :: vl=0. intent(hide) :: vu=1. integer intent(hide) :: il=1 integer intent(hide) :: iu=2 intent(hide) :: abstol=0. integer intent(hide) :: m=1 intent(hide) :: w intent(hide) :: z integer intent(hide),depend(n):: ldz = max(1,n) integer intent(hide) :: isuppz integer intent(hide) :: lwork = -1 integer intent(hide) :: liwork = -1 ! Outputs intent(out) :: work integer intent(out) :: iwork integer intent(out) :: info end subroutine syevr_lwork subroutine heevr(compute_v,range,lower,n,a,lda,vl,vu,il,iu,abstol,w,z,m,ldz,isuppz,work,lwork,rwork,lrwork,iwork,liwork,info) ! Standard Symmetric/HermitianEigenvalue Problem ! Complex - Single precision / Double precision ! ! if jobz = 'N' there are no eigvecs hence 0x0 'z' returned ! if jobz = 'V' and range = 'A', z is (nxn) ! if jobz = 'V' and range = 'V', z is (nxn) since returned number of eigs is unknown beforehand ! if jobz = 'V' and range = 'I', z is (nx(iu-il+1)) callstatement (*f2py_func)((compute_v?"V":"N"),range,(lower?"L":"U"),&n,a,&lda,&vl,&vu,&il,&iu,&abstol,&m,w,z,&ldz,isuppz,work,&lwork,rwork,&lrwork,iwork,&liwork,&info) callprotoargument char*,char*,char*,F_INT*,*,F_INT*,*,*,F_INT*,F_INT*,*,F_INT*,*,*,F_INT*,F_INT*,*,F_INT*,*,F_INT*,F_INT*,F_INT*,F_INT* intent(in,copy,aligned8),check(shape(a,0)==shape(a,1)),dimension(n,n) :: a integer optional,intent(in),check(compute_v==1||compute_v==0):: compute_v = 1 character optional,intent(in),check(*range=='A'||*range=='V' ||*range=='I') :: range='A' integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 integer optional,intent(in),check(il>=1&&il<=n),depend(n) :: il=1 integer optional,intent(in),check(n>=iu&&iu>=il),depend(n,il) :: iu=n optional,intent(in) :: vl=0.0 optional,intent(in),check(vu>vl),depend(vl) :: vu=1.0 intent(in) :: abstol=0.0 integer optional,intent(in),depend(n),check(lwork>=max(2*n,1)||lwork==-1) :: lwork=max(2*n,1) integer optional,intent(in),depend(n),check(lrwork>=max(24*n,1)||lrwork==-1) :: lrwork=max(24*n,1) integer optional,intent(in),depend(n),check(liwork>=max(1,10*n)||liwork==-1):: liwork= max(1,10*n) integer intent(hide),depend(a) :: n=shape(a,0) integer intent(hide),depend(n) :: lda=max(1,n) integer intent(hide),depend(z) :: ldz=max(1,shape(z,0)) intent(hide),dimension(lwork),depend(lwork) :: work intent(hide),dimension(lrwork),depend(lrwork) :: rwork integer intent(hide),dimension(liwork),depend(liwork) :: iwork intent(out),dimension(n),depend(n) :: w intent(out),dimension((compute_v?MAX(0,n):0),(compute_v?((*range=='I')?(iu-il+1):MAX(1,n)):0)),depend(n,compute_v,range,iu,il) :: z integer intent(out) :: m ! MKL implementation has a bug that still accesses isuppz array even if ! range=='A' or range=='I' and il, iu = 1, n which is not the case for ! the reference implementation. Hence here isuppz is allocated regardless ! of the settings. It is wasteful but necessary. The bug is fixed in ! mkl 2020 update 2 and when time comes change this line with ! ! integer intent(out),dimension((compute_v?(2*(*range=='A'||((*range=='I') && (iu-il+1==n))?n:0)):0)),depend(n,iu,il,range,compute_v) :: isuppz ! integer intent(out),dimension(2*max(1,n)),depend(n) :: isuppz integer intent(out) :: info end subroutine heevr subroutine heevr_lwork(n,lower,a,lda,vl,vu,il,iu,abstol,m,w,z,ldz,isuppz,work,lwork,rwork,lrwork,iwork,liwork,info) ! LWORK routines for (c/z)heevr fortranname heevr callstatement (*f2py_func)("N","A",(lower?"L":"U"),&n,&a,&lda,&vl,&vu,&il,&iu,&abstol,&m,&w,&z,&ldz,&isuppz,&work,&lwork,&rwork,&lrwork,&iwork,&liwork,&info) callprotoargument char*,char*,char*,F_INT*,*,F_INT*,*,*,F_INT*,F_INT*,*,F_INT*,*,*,F_INT*,F_INT*,*,F_INT*,*,F_INT*,F_INT*,F_INT*,F_INT* ! Inputs integer intent(in):: n integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 ! Not referenced intent(hide) :: a integer intent(hide),depend(n) :: lda = max(1,n) intent(hide) :: vl=0. intent(hide) :: vu=1. integer intent(hide) :: il=1 integer intent(hide) :: iu=2 intent(hide) :: abstol=0. integer intent(hide) :: m=1 intent(hide) :: w intent(hide) :: z integer intent(hide),depend(n):: ldz = max(1,n) integer intent(hide) :: isuppz integer intent(hide) :: lwork = -1 integer intent(hide) :: lrwork = -1 integer intent(hide) :: liwork = -1 ! Outputs intent(out) :: work intent(out) :: rwork integer intent(out) :: iwork integer intent(out) :: info end subroutine heevr_work subroutine syevx(compute_v,range,lower,n,a,lda,vl,vu,il,iu,abstol,w,z,m,ldz,work,lwork,iwork,ifail,info) ! DSYEVX computes selected eigenvalues and, optionally, eigenvectors ! of a real symmetric matrix A. Eigenvalues and eigenvectors can be ! selected by specifying either a range of values or a range of indices ! for the desired eigenvalues. callstatement (*f2py_func)((compute_v?"V":"N"),range,(lower?"L":"U"),&n,a,&lda,&vl,&vu,&il,&iu,&abstol,&m,w,z,&ldz,work,&lwork,iwork,ifail,&info) callprotoargument char*,char*,char*,F_INT*,*,F_INT*,*,*,F_INT*,F_INT*,*,F_INT*,*,*,F_INT*,*,F_INT*,F_INT*,F_INT*,F_INT* integer optional,intent(in),check(compute_v==1||compute_v==0):: compute_v = 1 character optional,intent(in),check(*range=='A'||*range=='V' ||*range=='I') :: range='A' integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 integer intent(hide),depend(a) :: n=shape(a,0) integer optional,intent(in),check(il>=1&&il<=n),depend(n) :: il=1 integer optional,intent(in),check(n>=iu&&iu>=il),depend(n,il) :: iu=n optional,intent(in) :: vl=0.0 optional,intent(in),check(vu>vl),depend(vl) :: vu=1.0 optional,intent(in) :: abstol=0.0 integer optional,intent(in),depend(n),check(lwork>=1||lwork==-1) :: lwork=max(8*n,1) intent(in,copy),check(shape(a,0)==shape(a,1)),dimension(n,n) :: a integer intent(hide),depend(a) :: lda=max(1,shape(a,0)) integer intent(hide),depend(z) :: ldz=max(1,shape(z,0)) intent(hide),dimension(lwork),depend(lwork) :: work integer intent(hide),dimension(5*n),depend(n) :: iwork intent(out),dimension(n),depend(n) :: w intent(out),dimension((compute_v?MAX(0,n):0),(compute_v?((*range=='I')?(iu-il+1):MAX(1,n)):0)),depend(n,compute_v,range,iu,il) :: z integer intent(out) :: m integer intent(out),dimension((compute_v?n:0)),depend(compute_v,n):: ifail integer intent(out) :: info end subroutine syevx subroutine syevx_lwork(lower,n,a,lda,vl,vu,il,iu,abstol,m,w,z,ldz,work,lwork,iwork,ifail,info) ! LWORK routines for (d/s)syevx fortranname syevx callstatement (*f2py_func)("N","A",(lower?"L":"U"),&n,&a,&lda,&vl,&vu,&il,&iu,&abstol,&m,&w,&z,&ldz,&work,&lwork,&iwork,&ifail,&info) callprotoargument char*,char*,char*,F_INT*,*,F_INT*,*,*,F_INT*,F_INT*,*,F_INT*,*,*,F_INT*,*,F_INT*,F_INT*,F_INT*,F_INT* integer intent(in):: n integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 intent(hide):: a integer intent(hide),depend(n):: lda = MAX(1,n) integer intent(hide):: il = 1 integer intent(hide):: iu = 0 intent(hide):: vl = 0.0 intent(hide):: vu = 1.0 intent(hide):: abstol = 0.0 integer intent(hide):: m intent(hide):: w intent(hide):: z integer intent(hide),depend(n):: ldz = MAX(1,n) integer intent(hide):: lwork = -1 integer intent(hide):: iwork integer intent(hide):: ifail intent(out):: work integer intent(out):: info end subroutine syevx_lwork subroutine heevx(compute_v,range,lower,n,a,lda,vl,vu,il,iu,abstol,w,z,m,ldz,work,lwork,rwork,iwork,ifail,info) ! (C/Z)HEEVX computes selected eigenvalues and, optionally, eigenvectors ! of a complex Hermitian matrix A. Eigenvalues and eigenvectors can ! be selected by specifying either a range of values or a range of ! indices for the desired eigenvalues. callstatement (*f2py_func)((compute_v?"V":"N"),range,(lower?"L":"U"),&n,a,&lda,&vl,&vu,&il,&iu,&abstol,&m,w,z,&ldz,work,&lwork,rwork,iwork,ifail,&info) callprotoargument char*,char*,char*,F_INT*,*,F_INT*,*,*,F_INT*,F_INT*,*,F_INT*,*,*,F_INT*,*,F_INT*,*,F_INT*,F_INT*,F_INT* integer optional,intent(in),check(compute_v==1||compute_v==0):: compute_v = 1 character optional,intent(in),check(*range=='A'||*range=='V' ||*range=='I') :: range='A' integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 integer optional,intent(in),check(il>=1&&il<=n),depend(n) :: il=1 integer optional,intent(in),check(n>=iu&&iu>=il),depend(n,il) :: iu=n optional,intent(in) :: vl=0.0 optional,intent(in),check(vu>vl),depend(vl) :: vu=1.0 optional,intent(in) :: abstol=0.0 integer optional,intent(in),depend(n),check(lwork>=1||lwork==-1) :: lwork=max(2*n,1) intent(in,copy),check(shape(a,0)==shape(a,1)),dimension(n,n) :: a integer intent(hide),depend(a) :: n=shape(a,0) integer intent(hide),depend(a) :: lda=max(1,shape(a,0)) integer intent(hide),depend(z) :: ldz=max(1,shape(z,0)) intent(hide),dimension(lwork),depend(lwork) :: work integer intent(hide),dimension(5*n),depend(n) :: iwork intent(hide),dimension(7*n),depend(n) :: rwork intent(out),dimension(n),depend(n) :: w intent(out),dimension((compute_v*n),(compute_v?((*range=='I')?(iu-il+1):MAX(1,n)):0)),depend(compute_v,range,n,iu,il) :: z integer intent(out) :: m integer intent(out),dimension(compute_v*n),depend(compute_v,n):: ifail integer intent(out) :: info end subroutine heevx subroutine heevx_lwork(lower,n,a,lda,vl,vu,il,iu,abstol,m,w,z,ldz,work,lwork,rwork,iwork,ifail,info) ! LWORK routines for (c/z)heevx fortranname heevx callstatement (*f2py_func)("N","A",(lower?"L":"U"),&n,&a,&lda,&vl,&vu,&il,&iu,&abstol,&m,&w,&z,&ldz,&work,&lwork,&rwork,&iwork,&ifail,&info) callprotoargument char*,char*,char*,F_INT*,*,F_INT*,*,*,F_INT*,F_INT*,*,F_INT*,*,*,F_INT*,*,F_INT*,*,F_INT*,F_INT*,F_INT* integer intent(in):: n integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 intent(hide):: a integer intent(hide),depend(n):: lda = MAX(1,n) integer intent(hide):: il = 1 integer intent(hide):: iu = 0 intent(hide):: vl = 0.0 intent(hide):: vu = 1.0 intent(hide):: abstol = 0.0 integer intent(hide):: m intent(hide):: w intent(hide):: z integer intent(hide),depend(n):: ldz = MAX(1,n) integer intent(hide):: lwork = -1 intent(hide):: rwork integer intent(hide):: iwork integer intent(hide):: ifail intent(out):: work integer intent(out):: info end subroutine heevx_lwork subroutine sygv(itype,jobz,uplo,n,lda,ldb,w,a,b,work,lwork,info) ! Generalized Symmetric Eigenvalue Problem ! Real - Single precision / Double precision ! ! if jobz = 'N' there are no eigvecs returned ! if jobz = 'V' 'a' contains eigvecs callstatement (*f2py_func)(&itype,jobz,uplo,&n,a,&lda,b,&ldb,w,work,&lwork,&info) callprotoargument F_INT*,char*,char*,F_INT*,*,F_INT*,*,F_INT*,*,*,F_INT*,F_INT* ! itype,jobz ,uplo , n , a ,lda , b , ldb, w , work ,lwork, info intent(in,copy,aligned8,out,out=v),check(shape(a,0)==shape(a,1)),dimension(n,n) :: a intent(in,copy,aligned8),check(shape(b,0)==shape(b,1)),check(shape(b,0)==n),dimension(n,n),depend(n) :: b integer optional,intent(in),check(itype > 0 || itype < 4) :: itype = 1 character optional,intent(in),check(*jobz=='N'||*jobz=='V') :: jobz='V' character optional,intent(in),check(*uplo=='U'||*uplo=='L') :: uplo='L' integer optional,intent(in),depend(n),check(lwork>0||lwork==-1) :: lwork=max(3*n-1,1) integer intent(hide),depend(a) :: n=shape(a,0) integer intent(hide),depend(n) :: lda=max(1,n) integer intent(hide),depend(b) :: ldb=max(1,shape(b,0)) intent(hide),dimension(lwork),depend(lwork) :: work intent(out),dimension(n),depend(n) :: w integer intent(out) :: info end subroutine sygv subroutine sygv_lwork(itype,jobz,uplo,n,a,lda,b,ldb,w,work,lwork,info) ! LWORK routine for (S,D)SYGV fortranname sygv callstatement (*f2py_func)(&itype,jobz,uplo,&n,&a,&lda,&b,&ldb,&w,&work,&lwork,&info) callprotoargument F_INT*,char*,char*,F_INT*,*,F_INT*,*,F_INT*,*,*,F_INT*,F_INT* ! Inputs integer intent(in):: n character optional,intent(in),check(*uplo=='U' || *uplo=='L') :: uplo='L' ! Not referenced integer intent(hide) :: itype=1 character intent(hide) :: jobz="N" intent(hide) :: a intent(hide) :: b integer intent(hide) :: lda=max(1,n) integer intent(hide) :: ldb=max(1,n) integer intent(hide) :: lwork=-1 intent(hide) :: w ! Outputs intent(out) :: work integer intent(out) :: info end subroutine sygv_lwork subroutine hegv(itype,jobz,uplo,n,lda,ldb,w,a,b,work,lwork,rwork,info) ! Generalized Symmetric Eigenvalue Problem ! Complex - Single precision / Double precision ! ! if jobz = 'N' there are no eigvecs returned ! if jobz = 'V' 'a' contains eigvecs callstatement (*f2py_func)(&itype,jobz,uplo,&n,a,&lda,b,&ldb,w,work,&lwork,rwork,&info) callprotoargument F_INT*,char*,char*,F_INT*,*,F_INT*,*,F_INT*,*,*,F_INT*,*,F_INT* ! itype,jobz ,uplo , n , a ,lda , b , ldb, w , work ,lwork,rwork ,info intent(in,copy,aligned8,out,out=v),check(shape(a,0)==shape(a,1)),dimension(n,n) :: a intent(in,copy,aligned8),check(shape(b,0)==shape(b,1)),check(shape(b,0)==n),dimension(n,n),depend(n) :: b integer optional,intent(in),check(itype > 0 || itype < 4) :: itype = 1 character optional,intent(in),check(*jobz=='N'||*jobz=='V') :: jobz='V' character optional,intent(in),check(*uplo=='U'||*uplo=='L') :: uplo='L' integer optional,intent(in),depend(n),check(lwork>0||lwork==-1) :: lwork=max(2*n-1,1) integer intent(hide),depend(a) :: n=shape(a,0) integer intent(hide),depend(n) :: lda=max(1,n) integer intent(hide),depend(b) :: ldb=max(1,shape(b,0)) intent(hide),dimension(lwork),depend(lwork) :: work intent(hide),dimension(MAX(1,3*n-2)),depend(n) :: rwork intent(out),dimension(n),depend(n) :: w integer intent(out) :: info end subroutine hegv subroutine hegv_lwork(itype,jobz,uplo,n,a,lda,b,ldb,w,work,lwork,rwork,info) ! LWORK Query routine for (c/z)hegv fortranname hegv callstatement (*f2py_func)(&itype,jobz,uplo,&n,&a,&lda,&b,&ldb,&w,&work,&lwork,&rwork,&info) callprotoargument F_INT*,char*,char*,F_INT*,*,F_INT*,*,F_INT*,*,*,F_INT*,*,F_INT* ! Inputs integer intent(in):: n character optional,intent(in),check(*uplo=='U' || *uplo=='L') :: uplo='L' ! Not referenced integer intent(hide) :: itype=1 character intent(hide) :: jobz="N" intent(hide) :: a intent(hide) :: b integer intent(hide),depend(n) :: lda=MAX(1,n) integer intent(hide),depend(n) :: ldb=MAX(1,n) integer intent(hide) :: lwork=-1 intent(hide) :: w intent(hide) :: rwork ! Outputs intent(out) :: work integer intent(out) :: info end subroutine hegv_lwork ! ! Divide and conquer routines for generalized eigenvalue problem ! subroutine sygvd(itype,jobz,uplo,n,lda,ldb,w,a,b,work,lwork,iwork,liwork,info) ! No call to ILAENV is performed. Hence no need for (d/s)sygvd_lwork. Default sizes are optimal. callstatement (*f2py_func)(&itype,jobz,uplo,&n,a,&lda,b,&ldb,w,work,&lwork,iwork,&liwork,&info) callprotoargument F_INT*,char*,char*,F_INT*,*,F_INT*,*,F_INT*,*,*,F_INT*,F_INT*,F_INT*,F_INT* intent(in,copy,aligned8,out,out=v),check(shape(a,0)==shape(a,1)),dimension(n,n) :: a intent(in,copy,aligned8),check(shape(b,0)==shape(b,1)),check(shape(b,0)==n),dimension(n,n),depend(n) :: b integer optional,intent(in),check(itype > 0 || itype < 4) :: itype = 1 character optional,intent(in),check(*jobz=='N'||*jobz=='V') :: jobz='V' character optional,intent(in),check(*uplo=='U'||*uplo=='L') :: uplo='L' integer optional,intent(in),depend(n),check(lwork>0||lwork==-1) :: lwork=(*jobz=='N'?2*n+1:1+6*n+2*n*n) integer optional,intent(in),depend(n),check(liwork>0||liwork==-1) :: liwork=(*jobz=='N'?1:5*n+3) integer intent(hide),depend(a) :: n=shape(a,0) integer intent(hide),depend(n) :: lda=max(1,n) integer intent(hide),depend(b) :: ldb=max(1,shape(b,0)) intent(hide),dimension(lwork),depend(lwork) :: work integer intent(hide),dimension(liwork),depend(liwork) :: iwork intent(out),dimension(n),depend(n) :: w integer intent(out) :: info end subroutine sygvd subroutine hegvd(itype,jobz,uplo,n,lda,ldb,w,a,b,work,lwork,rwork,lrwork,iwork,liwork,info) ! No call to ILAENV is performed. Hence no need for (c/z)hegvd_lwork. Default sizes are optimal. callstatement (*f2py_func)(&itype,jobz,uplo,&n,a,&lda,b,&ldb,w,work,&lwork,rwork,&lrwork,iwork,&liwork,&info) callprotoargument F_INT*,char*,char*,F_INT*,*,F_INT*,*,F_INT*,*,*,F_INT*,*,F_INT*,F_INT*,F_INT*,F_INT* intent(in,copy,aligned8,out,out=v),check(shape(a,0)==shape(a,1)),dimension(n,n) :: a intent(in,copy,aligned8),check(shape(b,0)==shape(b,1)),check(shape(b,0)==n),dimension(n,n),depend(n) :: b integer optional,intent(in),check(itype > 0 || itype < 4) :: itype = 1 character optional,intent(in),check(*jobz=='N'||*jobz=='V') :: jobz='V' character optional,intent(in),check(*uplo=='U'||*uplo=='L') :: uplo='L' integer optional,intent(in),depend(n),check(lwork>0||lwork==-1) :: lwork=(*jobz=='N'?n+1:n*(n+2)) integer optional,intent(in),depend(n),check(lrwork>0||lrwork==-1) :: lrwork=max((*jobz=='N'?n:2*n*n+5*n+1),1) integer optional,intent(in),depend(n),check(liwork>0||liwork==-1) :: liwork=(*jobz=='N'?1:5*n+3) integer intent(hide),depend(a) :: n=shape(a,0) integer intent(hide),depend(n) :: lda=max(1,n) integer intent(hide),depend(b) :: ldb=max(1,shape(b,0)) intent(hide),dimension(lwork),depend(lwork) :: work intent(hide),dimension(lrwork),depend(lrwork) :: rwork integer intent(hide),dimension(liwork),depend(liwork) :: iwork intent(out),dimension(n),depend(n) :: w integer intent(out) :: info end subroutine hegvd ! ! Expert routines for generalized eigenvalue problem ! subroutine sygvx(itype,jobz,range,uplo,n,a,lda,b,ldb,vl,vu,il,iu,abstol,w,z,m,ldz,work,lwork,iwork,ifail,info) ! (S/D)SYGVX computes selected eigenvalues, and optionally, eigenvectors ! of a real generalized symmetric-definite eigenproblem, of the form ! A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A ! and B are assumed to be symmetric and B is also positive definite. ! Eigenvalues and eigenvectors can be selected by specifying either a ! range of values or a range of indices for the desired eigenvalues. callstatement (*f2py_func)(&itype,jobz,range,uplo,&n,a,&lda,b,&ldb,&vl,&vu,&il,&iu,&abstol,&m,w,z,&ldz,work,&lwork,iwork,ifail,&info) callprotoargument F_INT*,char*,char*,char*,F_INT*,*,F_INT*,*,F_INT*,*,*,F_INT*,F_INT*,*,F_INT*,*,*,F_INT*,*,F_INT*,F_INT*,F_INT*,F_INT* integer optional,intent(in),check(itype>0||itype<4) :: itype=1 character optional,intent(in),check(*jobz=='N'||*jobz=='V') :: jobz="V" character optional,intent(in),check(*uplo=='U'||*uplo=='L') :: uplo="L" character optional,intent(in),check(*range=='A'||*range=='V' ||*range=='I') :: range="A" integer intent(hide),depend(a) :: n=shape(a,0) integer optional,intent(in) :: il=1 integer optional,intent(in),depend(n) :: iu=n optional,intent(in) :: vl=0.0 optional,intent(in),check(vu>vl),depend(vl) :: vu=1.0 intent(in) :: abstol=0.0 integer optional,intent(in),depend(n),check(lwork>=1||lwork==-1) :: lwork=max(8*n,1) intent(in,copy),check(shape(a,0)==shape(a,1)),dimension(n,n) :: a intent(in,copy,aligned8),check(shape(b,0)==shape(b,1)),check(shape(b,0)==n),dimension(n,n),depend(n) :: b integer intent(hide),depend(a) :: lda=MAX(1,shape(a,0)) integer intent(hide),depend(b) :: ldb=MAX(1,shape(b,0)) integer intent(hide),depend(z) :: ldz=MAX(1,shape(z,0)) intent(hide),dimension(lwork),depend(lwork) :: work integer intent(hide),dimension(5*n),depend(n) :: iwork intent(out),dimension(n),depend(n) :: w intent(out),dimension((jobz[0]=='V'?MAX(0,n):0),(jobz[0]=='V'?((range[0]=='I')?(iu-il+1):MAX(1,n)):0)),depend(n,jobz,range,iu,il) :: z integer intent(out) :: m integer intent(out),dimension((jobz[0]=='N'?0:n)),depend(jobz,n):: ifail integer intent(out) :: info end subroutine sygvx subroutine sygvx_lwork(itype,uplo,n,a,lda,b,ldb,vl,vu,il,iu,abstol,m,w,z,ldz,work,lwork,iwork,ifail,info) ! LWORK Query routine for (s/d)sygvx fortranname sygvx callstatement (*f2py_func)(&itype,"N","A",uplo,&n,&a,&lda,&b,&ldb,&vl,&vu,&il,&iu,&abstol,&m,&w,&z,&ldz,&work,&lwork,&iwork,&ifail,&info) callprotoargument F_INT*,char*,char*,char*,F_INT*,*,F_INT*,*,F_INT*,*,*,F_INT*,F_INT*,*,F_INT*,*,*,F_INT*,*,F_INT*,F_INT*,F_INT*,F_INT* integer intent(in):: n character optional,intent(in),check(*uplo=='U'||*uplo=='L') :: uplo='L' integer intent(hide):: itype = 1 intent(hide):: a integer intent(hide),depend(n):: lda = MAX(1,n) intent(hide):: b integer intent(hide):: ldb = MAX(1,n) integer intent(hide):: il = 1 integer intent(hide):: iu = 0 intent(hide):: vl = 0.0 intent(hide):: vu = 1.0 intent(hide):: abstol = 0.0 integer intent(hide):: m intent(hide):: w intent(hide):: z integer intent(hide),depend(n):: ldz = MAX(1,n) integer intent(hide):: lwork = -1 integer intent(hide):: iwork integer intent(hide):: ifail intent(out):: work integer intent(out):: info end subroutine sygvx_lwork subroutine hegvx(itype,jobz,range,uplo,n,a,lda,b,ldb,vl,vu,il,iu,abstol,w,z,m,ldz,work,lwork,rwork,iwork,ifail,info) ! (C/Z)HEGVX computes selected eigenvalues, and optionally, eigenvectors ! of a complex generalized Hermitian-definite eigenproblem, of the form ! A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and ! B are assumed to be Hermitian and B is also positive definite. ! Eigenvalues and eigenvectors can be selected by specifying either a ! range of values or a range of indices for the desired eigenvalues. callstatement (*f2py_func)(&itype,jobz,range,uplo,&n,a,&lda,b,&ldb,&vl,&vu,&il,&iu,&abstol,&m,w,z,&ldz,work,&lwork,rwork,iwork,ifail,&info) callprotoargument F_INT*,char*,char*,char*,F_INT*,*,F_INT*,*,F_INT*,*,*,F_INT*,F_INT*,*,F_INT*,*,*,F_INT*,*,F_INT*,*,F_INT*,F_INT*,F_INT* integer optional,intent(in),check(itype>0||itype<4) :: itype=1 character optional,intent(in),check(*jobz=='N'||*jobz=='V') :: jobz='V' character optional,intent(in),check(*uplo=='U'||*uplo=='L') :: uplo='L' character optional,intent(in),check(*range=='A'||*range=='V' ||*range=='I') :: range='A' integer intent(hide),depend(a) :: n=shape(a,0) integer optional,intent(in) :: il=1 integer optional,intent(in),depend(n) :: iu=n optional,intent(in) :: vl=0.0 optional,intent(in),check(vu>vl),depend(vl) :: vu=1.0 intent(in) :: abstol=0.0 integer optional,intent(in),depend(n),check(lwork>=1||lwork==-1) :: lwork=max(2*n,1) intent(in,copy),check(shape(a,0)==shape(a,1)),dimension(n,n) :: a intent(in,copy,aligned8),check(shape(b,0)==shape(b,1)),check(shape(b,0)==n),dimension(n,n),depend(n) :: b integer intent(hide),depend(n) :: lda=max(1,n) integer intent(hide),depend(n) :: ldb=max(1,n) integer intent(hide),depend(z) :: ldz=max(1,shape(z,0)) intent(hide),dimension(lwork),depend(lwork) :: work integer intent(hide),dimension(5*n),depend(n) :: iwork intent(hide),dimension(7*n),depend(n) :: rwork intent(out),dimension(n),depend(n) :: w intent(out),dimension((jobz[0]=='V'?MAX(0,n):0),(jobz[0]=='V'?((range[0]=='I')?(iu-il+1):MAX(1,n)):0)),depend(n,jobz,range,iu,il) :: z integer intent(out) :: m integer intent(out),dimension((jobz[0]=='N'?0:n)),depend(jobz,n):: ifail integer intent(out) :: info end subroutine hegvx subroutine hegvx_lwork(itype,uplo,n,a,lda,b,ldb,vl,vu,il,iu,abstol,m,w,z,ldz,work,lwork,rwork,iwork,ifail,info) ! LWORK Query routine for (c/z)hegvx fortranname hegvx callstatement (*f2py_func)(&itype,"N","A",uplo,&n,&a,&lda,&b,&ldb,&vl,&vu,&il,&iu,&abstol,&m,&w,&z,&ldz,&work,&lwork,&rwork,&iwork,&ifail,&info) callprotoargument F_INT*,char*,char*,char*,F_INT*,*,F_INT*,*,F_INT*,*,*,F_INT*,F_INT*,*,F_INT*,*,*,F_INT*,*,F_INT*,*,F_INT*,F_INT*,F_INT* integer intent(in):: n character optional,intent(in),check(*uplo=='U'||*uplo=='L') :: uplo='L' integer intent(hide):: itype = 1 intent(hide):: a integer intent(hide),depend(n):: lda = MAX(1,n) intent(hide):: b integer intent(hide):: ldb = MAX(1,n) integer intent(hide):: il = 1 integer intent(hide):: iu = 0 intent(hide):: vl = 0.0 intent(hide):: vu = 1.0 intent(hide):: abstol = 0.0 integer intent(hide):: m intent(hide):: w intent(hide):: z integer intent(hide),depend(n):: ldz = MAX(1,n) integer intent(hide):: lwork = -1 intent(hide):: rwork integer intent(hide):: iwork integer intent(hide):: ifail intent(out):: work integer intent(out):: info end subroutine hegvx_lwork subroutine syequb(lower,n,a,lda,s,scond,amax,work,info) callstatement (*f2py_func)((lower?"L":"U"),&n,a,&lda,s,&scond,&amax,work,&info) callprotoargument char*,F_INT*,*,F_INT*,*,*,*,*,F_INT* integer intent(hide),depend(a) :: n = shape(a,1) integer intent(hide),depend(a) :: lda = MAX(1,shape(a,0)) ! See https://github.com/Reference-LAPACK/lapack/pull/61 for the reason for 3*n intent(hide,cache),depend(n),dimension(3*n) :: work integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 intent(in),dimension(lda,n),check(shape(a,0)==shape(a,1)) :: a intent(out),dimension(n),depend(n) :: s intent(out) :: scond intent(out) :: amax integer intent(out) :: info end subroutine syequb subroutine heequb(lower,n,a,lda,s,scond,amax,work,info) callstatement (*f2py_func)((lower?"L":"U"),&n,a,&lda,s,&scond,&amax,work,&info) callprotoargument char*,F_INT*,*,F_INT*,*,*,*,*,F_INT* integer intent(hide),depend(a) :: n = shape(a,1) integer intent(hide),depend(a) :: lda = MAX(1,shape(a,0)) ! See https://github.com/Reference-LAPACK/lapack/pull/61 for the reason for 3*n intent(hide,cache),depend(n),dimension(3*n) :: work integer optional,intent(in),check(lower==0||lower==1) :: lower = 0 intent(in),dimension(lda,n),check(shape(a,0)==shape(a,1)) :: a intent(out),dimension(n),depend(n) :: s intent(out) :: scond intent(out) :: amax integer intent(out) :: info end subroutine heequb