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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
---
:name: dlagtf
:md5sum: 3a0ef4d4c7ee1d1045339e13d37e6877
:category: :subroutine
:arguments:
- n:
:type: integer
:intent: input
- a:
:type: doublereal
:intent: input/output
:dims:
- n
- lambda:
:type: doublereal
:intent: input
- b:
:type: doublereal
:intent: input/output
:dims:
- n-1
- c:
:type: doublereal
:intent: input/output
:dims:
- n-1
- tol:
:type: doublereal
:intent: input
- d:
:type: doublereal
:intent: output
:dims:
- n-2
- in:
:type: integer
:intent: output
:dims:
- n
- info:
:type: integer
:intent: output
:substitutions: {}
:fortran_help: " SUBROUTINE DLAGTF( N, A, LAMBDA, B, C, TOL, D, IN, INFO )\n\n\
* Purpose\n\
* =======\n\
*\n\
* DLAGTF factorizes the matrix (T - lambda*I), where T is an n by n\n\
* tridiagonal matrix and lambda is a scalar, as\n\
*\n\
* T - lambda*I = PLU,\n\
*\n\
* where P is a permutation matrix, L is a unit lower tridiagonal matrix\n\
* with at most one non-zero sub-diagonal elements per column and U is\n\
* an upper triangular matrix with at most two non-zero super-diagonal\n\
* elements per column.\n\
*\n\
* The factorization is obtained by Gaussian elimination with partial\n\
* pivoting and implicit row scaling.\n\
*\n\
* The parameter LAMBDA is included in the routine so that DLAGTF may\n\
* be used, in conjunction with DLAGTS, to obtain eigenvectors of T by\n\
* inverse iteration.\n\
*\n\n\
* Arguments\n\
* =========\n\
*\n\
* N (input) INTEGER\n\
* The order of the matrix T.\n\
*\n\
* A (input/output) DOUBLE PRECISION array, dimension (N)\n\
* On entry, A must contain the diagonal elements of T.\n\
*\n\
* On exit, A is overwritten by the n diagonal elements of the\n\
* upper triangular matrix U of the factorization of T.\n\
*\n\
* LAMBDA (input) DOUBLE PRECISION\n\
* On entry, the scalar lambda.\n\
*\n\
* B (input/output) DOUBLE PRECISION array, dimension (N-1)\n\
* On entry, B must contain the (n-1) super-diagonal elements of\n\
* T.\n\
*\n\
* On exit, B is overwritten by the (n-1) super-diagonal\n\
* elements of the matrix U of the factorization of T.\n\
*\n\
* C (input/output) DOUBLE PRECISION array, dimension (N-1)\n\
* On entry, C must contain the (n-1) sub-diagonal elements of\n\
* T.\n\
*\n\
* On exit, C is overwritten by the (n-1) sub-diagonal elements\n\
* of the matrix L of the factorization of T.\n\
*\n\
* TOL (input) DOUBLE PRECISION\n\
* On entry, a relative tolerance used to indicate whether or\n\
* not the matrix (T - lambda*I) is nearly singular. TOL should\n\
* normally be chose as approximately the largest relative error\n\
* in the elements of T. For example, if the elements of T are\n\
* correct to about 4 significant figures, then TOL should be\n\
* set to about 5*10**(-4). If TOL is supplied as less than eps,\n\
* where eps is the relative machine precision, then the value\n\
* eps is used in place of TOL.\n\
*\n\
* D (output) DOUBLE PRECISION array, dimension (N-2)\n\
* On exit, D is overwritten by the (n-2) second super-diagonal\n\
* elements of the matrix U of the factorization of T.\n\
*\n\
* IN (output) INTEGER array, dimension (N)\n\
* On exit, IN contains details of the permutation matrix P. If\n\
* an interchange occurred at the kth step of the elimination,\n\
* then IN(k) = 1, otherwise IN(k) = 0. The element IN(n)\n\
* returns the smallest positive integer j such that\n\
*\n\
* abs( u(j,j) ).le. norm( (T - lambda*I)(j) )*TOL,\n\
*\n\
* where norm( A(j) ) denotes the sum of the absolute values of\n\
* the jth row of the matrix A. If no such j exists then IN(n)\n\
* is returned as zero. If IN(n) is returned as positive, then a\n\
* diagonal element of U is small, indicating that\n\
* (T - lambda*I) is singular or nearly singular,\n\
*\n\
* INFO (output) INTEGER\n\
* = 0 : successful exit\n\
* .lt. 0: if INFO = -k, the kth argument had an illegal value\n\
*\n\n\
* =====================================================================\n\
*\n"
|
