1: #region Translated by Jose Antonio De Santiago-Castillo.
2:
3: //Translated by Jose Antonio De Santiago-Castillo.
4: //E-mail:JAntonioDeSantiago@gmail.com
5: //Web: www.DotNumerics.com
6: //
7: //Fortran to C# Translation.
8: //Translated by:
9: //F2CSharp Version 0.71 (November 10, 2009)
10: //Code Optimizations: None
11: //
12: #endregion
13:
14: using System;
15: using DotNumerics.FortranLibrary;
16:
17: namespace DotNumerics.CSLapack
18: {
19: /// <summary>
20: /// -- LAPACK auxiliary routine (version 3.1) --
21: /// Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..
22: /// November 2006
23: /// Purpose
24: /// =======
25: ///
26: /// DLANSB returns the value of the one norm, or the Frobenius norm, or
27: /// the infinity norm, or the element of largest absolute value of an
28: /// n by n symmetric band matrix A, with k super-diagonals.
29: ///
30: /// Description
31: /// ===========
32: ///
33: /// DLANSB returns the value
34: ///
35: /// DLANSB = ( max(abs(A(i,j))), NORM = 'M' or 'm'
36: /// (
37: /// ( norm1(A), NORM = '1', 'O' or 'o'
38: /// (
39: /// ( normI(A), NORM = 'I' or 'i'
40: /// (
41: /// ( normF(A), NORM = 'F', 'f', 'E' or 'e'
42: ///
43: /// where norm1 denotes the one norm of a matrix (maximum column sum),
44: /// normI denotes the infinity norm of a matrix (maximum row sum) and
45: /// normF denotes the Frobenius norm of a matrix (square root of sum of
46: /// squares). Note that max(abs(A(i,j))) is not a consistent matrix norm.
47: ///
48: ///</summary>
49: public class DLANSB
50: {
51:
52:
53: #region Dependencies
54:
55: DLASSQ _dlassq; LSAME _lsame;
56:
57: #endregion
58:
59:
60: #region Fields
61:
62: const double ONE = 1.0E+0; const double ZERO = 0.0E+0; int I = 0; int J = 0; int L = 0; double ABSA = 0; double SCALE = 0;
63: double SUM = 0;double VALUE = 0;
64:
65: #endregion
66:
67: public DLANSB(DLASSQ dlassq, LSAME lsame)
68: {
69:
70:
71: #region Set Dependencies
72:
73: this._dlassq = dlassq; this._lsame = lsame;
74:
75: #endregion
76:
77: }
78:
79: public DLANSB()
80: {
81:
82:
83: #region Dependencies (Initialization)
84:
85: DLASSQ dlassq = new DLASSQ();
86: LSAME lsame = new LSAME();
87:
88: #endregion
89:
90:
91: #region Set Dependencies
92:
93: this._dlassq = dlassq; this._lsame = lsame;
94:
95: #endregion
96:
97: }
98: /// <summary>
99: /// Purpose
100: /// =======
101: ///
102: /// DLANSB returns the value of the one norm, or the Frobenius norm, or
103: /// the infinity norm, or the element of largest absolute value of an
104: /// n by n symmetric band matrix A, with k super-diagonals.
105: ///
106: /// Description
107: /// ===========
108: ///
109: /// DLANSB returns the value
110: ///
111: /// DLANSB = ( max(abs(A(i,j))), NORM = 'M' or 'm'
112: /// (
113: /// ( norm1(A), NORM = '1', 'O' or 'o'
114: /// (
115: /// ( normI(A), NORM = 'I' or 'i'
116: /// (
117: /// ( normF(A), NORM = 'F', 'f', 'E' or 'e'
118: ///
119: /// where norm1 denotes the one norm of a matrix (maximum column sum),
120: /// normI denotes the infinity norm of a matrix (maximum row sum) and
121: /// normF denotes the Frobenius norm of a matrix (square root of sum of
122: /// squares). Note that max(abs(A(i,j))) is not a consistent matrix norm.
123: ///
124: ///</summary>
125: /// <param name="NORM">
126: /// (input) CHARACTER*1
127: /// Specifies the value to be returned in DLANSB as described
128: /// above.
129: ///</param>
130: /// <param name="UPLO">
131: /// (input) CHARACTER*1
132: /// Specifies whether the upper or lower triangular part of the
133: /// band matrix A is supplied.
134: /// = 'U': Upper triangular part is supplied
135: /// = 'L': Lower triangular part is supplied
136: ///</param>
137: /// <param name="N">
138: /// (input) INTEGER
139: /// The order of the matrix A. N .GE. 0. When N = 0, DLANSB is
140: /// set to zero.
141: ///</param>
142: /// <param name="K">
143: /// (input) INTEGER
144: /// The number of super-diagonals or sub-diagonals of the
145: /// band matrix A. K .GE. 0.
146: ///</param>
147: /// <param name="AB">
148: /// (input) DOUBLE PRECISION array, dimension (LDAB,N)
149: /// The upper or lower triangle of the symmetric band matrix A,
150: /// stored in the first K+1 rows of AB. The j-th column of A is
151: /// stored in the j-th column of the array AB as follows:
152: /// if UPLO = 'U', AB(k+1+i-j,j) = A(i,j) for max(1,j-k).LE.i.LE.j;
153: /// if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j.LE.i.LE.min(n,j+k).
154: ///</param>
155: /// <param name="LDAB">
156: /// (input) INTEGER
157: /// The leading dimension of the array AB. LDAB .GE. K+1.
158: ///</param>
159: /// <param name="WORK">
160: /// (workspace) DOUBLE PRECISION array, dimension (MAX(1,LWORK)),
161: /// where LWORK .GE. N when NORM = 'I' or '1' or 'O'; otherwise,
162: /// WORK is not referenced.
163: ///</param>
164: public double Run(string NORM, string UPLO, int N, int K, double[] AB, int offset_ab, int LDAB
165: , ref double[] WORK, int offset_work)
166: {
167: double dlansb = 0;
168:
169: #region Array Index Correction
170:
171: int o_ab = -1 - LDAB + offset_ab; int o_work = -1 + offset_work;
172:
173: #endregion
174:
175:
176: #region Strings
177:
178: NORM = NORM.Substring(0, 1); UPLO = UPLO.Substring(0, 1);
179:
180: #endregion
181:
182:
183: #region Prolog
184:
185: // *
186: // * -- LAPACK auxiliary routine (version 3.1) --
187: // * Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..
188: // * November 2006
189: // *
190: // * .. Scalar Arguments ..
191: // * ..
192: // * .. Array Arguments ..
193: // * ..
194: // *
195: // * Purpose
196: // * =======
197: // *
198: // * DLANSB returns the value of the one norm, or the Frobenius norm, or
199: // * the infinity norm, or the element of largest absolute value of an
200: // * n by n symmetric band matrix A, with k super-diagonals.
201: // *
202: // * Description
203: // * ===========
204: // *
205: // * DLANSB returns the value
206: // *
207: // * DLANSB = ( max(abs(A(i,j))), NORM = 'M' or 'm'
208: // * (
209: // * ( norm1(A), NORM = '1', 'O' or 'o'
210: // * (
211: // * ( normI(A), NORM = 'I' or 'i'
212: // * (
213: // * ( normF(A), NORM = 'F', 'f', 'E' or 'e'
214: // *
215: // * where norm1 denotes the one norm of a matrix (maximum column sum),
216: // * normI denotes the infinity norm of a matrix (maximum row sum) and
217: // * normF denotes the Frobenius norm of a matrix (square root of sum of
218: // * squares). Note that max(abs(A(i,j))) is not a consistent matrix norm.
219: // *
220: // * Arguments
221: // * =========
222: // *
223: // * NORM (input) CHARACTER*1
224: // * Specifies the value to be returned in DLANSB as described
225: // * above.
226: // *
227: // * UPLO (input) CHARACTER*1
228: // * Specifies whether the upper or lower triangular part of the
229: // * band matrix A is supplied.
230: // * = 'U': Upper triangular part is supplied
231: // * = 'L': Lower triangular part is supplied
232: // *
233: // * N (input) INTEGER
234: // * The order of the matrix A. N >= 0. When N = 0, DLANSB is
235: // * set to zero.
236: // *
237: // * K (input) INTEGER
238: // * The number of super-diagonals or sub-diagonals of the
239: // * band matrix A. K >= 0.
240: // *
241: // * AB (input) DOUBLE PRECISION array, dimension (LDAB,N)
242: // * The upper or lower triangle of the symmetric band matrix A,
243: // * stored in the first K+1 rows of AB. The j-th column of A is
244: // * stored in the j-th column of the array AB as follows:
245: // * if UPLO = 'U', AB(k+1+i-j,j) = A(i,j) for max(1,j-k)<=i<=j;
246: // * if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(n,j+k).
247: // *
248: // * LDAB (input) INTEGER
249: // * The leading dimension of the array AB. LDAB >= K+1.
250: // *
251: // * WORK (workspace) DOUBLE PRECISION array, dimension (MAX(1,LWORK)),
252: // * where LWORK >= N when NORM = 'I' or '1' or 'O'; otherwise,
253: // * WORK is not referenced.
254: // *
255: // * =====================================================================
256: // *
257: // * .. Parameters ..
258: // * ..
259: // * .. Local Scalars ..
260: // * ..
261: // * .. External Subroutines ..
262: // * ..
263: // * .. External Functions ..
264: // * ..
265: // * .. Intrinsic Functions ..
266: // INTRINSIC ABS, MAX, MIN, SQRT;
267: // * ..
268: // * .. Executable Statements ..
269: // *
270:
271: #endregion
272:
273:
274: #region Body
275:
276: if (N == 0)
277: {
278: VALUE = ZERO;
279: }
280: else
281: {
282: if (this._lsame.Run(NORM, "M"))
283: {
284: // *
285: // * Find max(abs(A(i,j))).
286: // *
287: VALUE = ZERO;
288: if (this._lsame.Run(UPLO, "U"))
289: {
290: for (J = 1; J <= N; J++)
291: {
292: for (I = Math.Max(K + 2 - J, 1); I <= K + 1; I++)
293: {
294: VALUE = Math.Max(VALUE, Math.Abs(AB[I+J * LDAB + o_ab]));
295: }
296: }
297: }
298: else
299: {
300: for (J = 1; J <= N; J++)
301: {
302: for (I = 1; I <= Math.Min(N + 1 - J, K + 1); I++)
303: {
304: VALUE = Math.Max(VALUE, Math.Abs(AB[I+J * LDAB + o_ab]));
305: }
306: }
307: }
308: }
309: else
310: {
311: if ((this._lsame.Run(NORM, "I")) || (this._lsame.Run(NORM, "O")) || (NORM == "1"))
312: {
313: // *
314: // * Find normI(A) ( = norm1(A), since A is symmetric).
315: // *
316: VALUE = ZERO;
317: if (this._lsame.Run(UPLO, "U"))
318: {
319: for (J = 1; J <= N; J++)
320: {
321: SUM = ZERO;
322: L = K + 1 - J;
323: for (I = Math.Max(1, J - K); I <= J - 1; I++)
324: {
325: ABSA = Math.Abs(AB[L + I+J * LDAB + o_ab]);
326: SUM = SUM + ABSA;
327: WORK[I + o_work] = WORK[I + o_work] + ABSA;
328: }
329: WORK[J + o_work] = SUM + Math.Abs(AB[K + 1+J * LDAB + o_ab]);
330: }
331: for (I = 1; I <= N; I++)
332: {
333: VALUE = Math.Max(VALUE, WORK[I + o_work]);
334: }
335: }
336: else
337: {
338: for (I = 1; I <= N; I++)
339: {
340: WORK[I + o_work] = ZERO;
341: }
342: for (J = 1; J <= N; J++)
343: {
344: SUM = WORK[J + o_work] + Math.Abs(AB[1+J * LDAB + o_ab]);
345: L = 1 - J;
346: for (I = J + 1; I <= Math.Min(N, J + K); I++)
347: {
348: ABSA = Math.Abs(AB[L + I+J * LDAB + o_ab]);
349: SUM = SUM + ABSA;
350: WORK[I + o_work] = WORK[I + o_work] + ABSA;
351: }
352: VALUE = Math.Max(VALUE, SUM);
353: }
354: }
355: }
356: else
357: {
358: if ((this._lsame.Run(NORM, "F")) || (this._lsame.Run(NORM, "E")))
359: {
360: // *
361: // * Find normF(A).
362: // *
363: SCALE = ZERO;
364: SUM = ONE;
365: if (K > 0)
366: {
367: if (this._lsame.Run(UPLO, "U"))
368: {
369: for (J = 2; J <= N; J++)
370: {
371: this._dlassq.Run(Math.Min(J - 1, K), AB, Math.Max(K + 2 - J, 1)+J * LDAB + o_ab, 1, ref SCALE, ref SUM);
372: }
373: L = K + 1;
374: }
375: else
376: {
377: for (J = 1; J <= N - 1; J++)
378: {
379: this._dlassq.Run(Math.Min(N - J, K), AB, 2+J * LDAB + o_ab, 1, ref SCALE, ref SUM);
380: }
381: L = 1;
382: }
383: SUM = 2 * SUM;
384: }
385: else
386: {
387: L = 1;
388: }
389: this._dlassq.Run(N, AB, L+1 * LDAB + o_ab, LDAB, ref SCALE, ref SUM);
390: VALUE = SCALE * Math.Sqrt(SUM);
391: }
392: }
393: }
394: }
395: // *
396: dlansb = VALUE;
397: return dlansb;
398: // *
399: // * End of DLANSB
400: // *
401:
402: #endregion
403:
404: }
405: }
406: }