! Signatures for f2py-wrappers of FORTRAN LAPACK Positive Definite Tridiagonal Matrix functions. ! subroutine ptsv(n, nrhs, d, e, b, info) callstatement (*f2py_func)(&n, &nrhs, d, e, b, &n, &info); callprotoargument F_INT*, F_INT*, *, *, *, F_INT*, F_INT* integer intent(hide), depend(d) :: n = len(d) integer intent(hide), depend(b) :: nrhs = shape(b, 1) dimension(n), intent(in,out,copy) :: d dimension(n-1), intent(in,out,copy,out=du), depend(n) :: e dimension(n,nrhs), intent(in,out,copy,out=x), depend(n), check(shape(b,0)==n) :: b integer intent(out) :: info end subroutine ptsv subroutine pttrf(n, d, e, info) ! d, e, info = pttrf(d, e, overwrite_d=0, overwrite_e=0) ! ! ?PTTRF computes the L*D*L**T factorization of a symmetric positive ! definite tridiagonal matrix A. The factorization may also be regarded ! as ! having the form A = U**T*D*U. callstatement (*f2py_func)(&n, d, e, &info) callprotoargument F_INT*, *, *, F_INT* integer intent(hide), depend(d) :: n = len(d) intent(in, out, copy), dimension(n) :: d intent(in, out, copy), dimension((n>0?n-1:0)), depend(n) :: e integer intent(out) :: info end subroutine pttrf subroutine pttrs(n, nrhs, d, e, b, ldb, info) ! x, info = pttrs(d, e, b, overwrite_b=0) ! ! DPTTRS solves a tridiagonal system of the form ! ! A * X = B ! ! using the L*D*L**T factorization of A computed by DPTTRF. D is a ! diagonal matrix specified in the vector D, L is a unit bidiagonal ! matrix whose subdiagonal is specified in the vector E, and X and B ! are N by NRHS matrices. callstatement (*f2py_func)(&n, &nrhs, d, e, b, &ldb, &info) callprotoargument F_INT*, F_INT*, *, *, *, F_INT*, F_INT* integer intent(hide), depend(d) :: n = len(d) intent(in), dimension(n) :: d intent(in), dimension((n>0?n-1:0)), depend(n) :: e intent(in, out, copy, out=x), dimension(ldb, nrhs) :: b integer intent(hide), depend(b) :: ldb = MAX(1, shape(b, 0)) integer intent(hide), depend(b) :: nrhs = shape(b, 1) integer intent(out) :: info end subroutinepttrs subroutine pttrs(lower, n, nrhs, d, e, b, ldb, info) ! x, info = pttrs(d, e, b, lower=0, overwrite_b=0) ! ! ?PTTRS solves a tridiagonal system of the form ! ! A * X = B ! ! using the L*D*L**T factorization of A computed by DPTTRF. D is a ! diagonal matrix specified in the vector D, L is a unit bidiagonal ! matrix whose subdiagonal is specified in the vector E, and X and B ! are N by NRHS matrices. callstatement (*f2py_func)((lower?"L":"U"), &n, &nrhs, d, e, b, &ldb, &info) callprotoargument char*, F_INT*, F_INT*, *, *, *, F_INT*, F_INT* integer optional, intent(in), check(lower==0||lower==1) :: lower = 0 integer intent(hide), depend(d) :: n = len(d) intent(in), dimension(n) :: d intent(in), dimension((n>0?n-1:0)), depend(n) :: e intent(in, out, copy, out=x), dimension(ldb, nrhs) :: b integer intent(hide), depend(b) :: ldb = MAX(1, shape(b, 0)) integer intent(hide), depend(b) :: nrhs = shape(b, 1) integer intent(out) :: info end subroutinepttrs subroutine pteqr(compute_z, n, d, e, z, ldz, work, info) ! d, e, z, work, info = pteqr(d, e, z, compute_z=0, overwrite_d=0, overwrite_e=0, overwrite_z=0) ! ?PTEQR computes all eigenvalues and, optionally, eigenvectors of a ! symmetric positive definite tridiagonal matrix. ! ! This routine computes the eigenvalues of the positive definite ! tridiagonal matrix to high relative accuracy. This means that if the ! eigenvalues range over many orders of magnitude in size, then the ! small eigenvalues and corresponding eigenvectors will be computed ! more accurately than, for example, with the standard QR method. ! ! The eigenvectors of a full or band positive definite Hermitian matrix ! can also be found if ?HETRD, ?HPTRD, or ?HBTRD has been used to ! reduce this matrix to tridiagonal form. (The reduction to ! tridiagonal form, however, may preclude the possibility of obtaining ! high relative accuracy in the small eigenvalues of the original ! matrix, if these eigenvalues range over many orders of magnitude.) callstatement (*f2py_func)((compute_z?(compute_z==2?"I":"V"):"N"), &n, d, e, z, &ldz, work, &info) callprotoargument char*, F_INT*, *, *, *, F_INT*, *, F_INT* integer intent(in, optional), check((compute_z>=0) && (compute_z<=2)) :: compute_z = 0 integer intent(hide), depend(d) :: n = len(d) intent(in,out,copy), dimension(n) :: d intent(in,out,copy), depend(n), dimension((n>0?n-1:0)) :: e intent(in,out,copy), depend(n), dimension((compute_z==0?shape(z, 0):max(1,n)),(compute_z==0?shape(z, 1):n)) :: z integer intent(hide), depend(z,n,compute_z) :: ldz = (compute_z==0)?1:max(1, shape(z, 0)) intent(hide), dimension(4*n) :: work integer intent(out) :: info end subroutine pteqr subroutine ptsvx(fact, n, nrhs, d, e, df, ef, b, ldb, x, ldx, rcond, ferr, berr, work, info) ! DPTSVX uses the factorization A = L*D*L**T to compute the solution ! to a real system of linear equations A*X = B, where A is an N-by-N ! symmetric positive definite tridiagonal matrix and X and B are !N-by-NRHS matrices. ! ! Error bounds on the solution and a condition estimate are also ! provided. callstatement (*f2py_func)(fact, &n, &nrhs, d, e, df, ef, b, &ldb, x, &ldx, &rcond, ferr, berr, work, &info) callprotoargument char*, F_INT*, F_INT*, *, *, *, *, *, F_INT*, *, F_INT*, *, *, *, *, F_INT* character optional, intent(in) :: fact = 'N' integer intent(hide), depend(d) :: n = len(d) integer intent(hide), depend(b) :: nrhs = shape(b, 1) intent(in), dimension(n) :: d intent(in), depend(n), dimension(max(0, n-1)) :: e optional, intent(in,out), depend(n), dimension(n) :: df optional, intent(in,out), depend(n), dimension(max(0, n-1)) :: ef intent(in), depend(n), dimension(ldb, nrhs), check(shape(b, 0) >= n):: b integer intent(hide), depend(b) :: ldb = max(1, shape(b, 0)) intent(out), dimension(ldx, nrhs) :: x integer intent(hide), depend(n) :: ldx = n intent(out) :: rcond intent(out), depend(nrhs), dimension(nrhs) :: ferr intent(out), depend(nrhs), dimension(nrhs) :: berr intent(hide,cache), depend(n), dimension(2*n) :: work integer intent(out) :: info end subroutine ptsvx subroutine ptsvx(fact, n, nrhs, d, e, df, ef, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info) ! DPTSVX uses the factorization A = L*D*L**T to compute the solution ! to a real system of linear equations A*X = B, where A is an N-by-N ! symmetric positive definite tridiagonal matrix and X and B are !N-by-NRHS matrices. ! ! Error bounds on the solution and a condition estimate are also ! provided. callstatement (*f2py_func)(fact, &n, &nrhs, d, e, df, ef, b, &ldb, x, &ldx, &rcond, ferr, berr, work, rwork, &info) callprotoargument char*, F_INT*, F_INT*, *, *, *, *, *, F_INT*, *, F_INT*, *, *, *, *, *, F_INT* character optional, intent(in) :: fact = 'N' integer intent(hide), depend(d) :: n = len(d) integer intent(hide), depend(b) :: nrhs = shape(b, 1) intent(in), dimension(n) :: d intent(in), depend(n), dimension(max(0, n-1)) :: e optional, intent(in,out), depend(n), dimension(n) :: df optional, intent(in,out), depend(n), dimension(max(0, n-1)) :: ef intent(in), depend(n), dimension(ldb, nrhs), check(shape(b,0) >= n) :: b integer intent(hide), depend(b) :: ldb = max(1, shape(b, 0)) intent(out), dimension(ldx, nrhs) :: x integer intent(hide), depend(n) :: ldx = n intent(out) :: rcond intent(out), depend(nrhs), dimension(nrhs) :: ferr intent(out), depend(nrhs), dimension(nrhs) :: berr intent(hide,cache), depend(n), dimension(n) :: work intent(hide,cache), depend(n), dimension(n) :: rwork integer intent(out) :: info end subroutine ptsvx