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 driver routine (version 3.1) --
21: /// Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..
22: /// November 2006
23: /// Purpose
24: /// =======
25: ///
26: /// DGESV computes the solution to a real system of linear equations
27: /// A * X = B,
28: /// where A is an N-by-N matrix and X and B are N-by-NRHS matrices.
29: ///
30: /// The LU decomposition with partial pivoting and row interchanges is
31: /// used to factor A as
32: /// A = P * L * U,
33: /// where P is a permutation matrix, L is unit lower triangular, and U is
34: /// upper triangular. The factored form of A is then used to solve the
35: /// system of equations A * X = B.
36: ///
37: ///</summary>
38: public class DGESV
39: {
40:
41:
42: #region Dependencies
43:
44: DGETRF _dgetrf; DGETRS _dgetrs; XERBLA _xerbla;
45:
46: #endregion
47:
48: public DGESV(DGETRF dgetrf, DGETRS dgetrs, XERBLA xerbla)
49: {
50:
51:
52: #region Set Dependencies
53:
54: this._dgetrf = dgetrf; this._dgetrs = dgetrs; this._xerbla = xerbla;
55:
56: #endregion
57:
58: }
59:
60: public DGESV()
61: {
62:
63:
64: #region Dependencies (Initialization)
65:
66: LSAME lsame = new LSAME();
67: XERBLA xerbla = new XERBLA();
68: DLAMC3 dlamc3 = new DLAMC3();
69: IDAMAX idamax = new IDAMAX();
70: DSCAL dscal = new DSCAL();
71: DSWAP dswap = new DSWAP();
72: DLASWP dlaswp = new DLASWP();
73: IEEECK ieeeck = new IEEECK();
74: IPARMQ iparmq = new IPARMQ();
75: DGEMM dgemm = new DGEMM(lsame, xerbla);
76: DLAMC1 dlamc1 = new DLAMC1(dlamc3);
77: DLAMC4 dlamc4 = new DLAMC4(dlamc3);
78: DLAMC5 dlamc5 = new DLAMC5(dlamc3);
79: DLAMC2 dlamc2 = new DLAMC2(dlamc3, dlamc1, dlamc4, dlamc5);
80: DLAMCH dlamch = new DLAMCH(lsame, dlamc2);
81: DGER dger = new DGER(xerbla);
82: DGETF2 dgetf2 = new DGETF2(dlamch, idamax, dger, dscal, dswap, xerbla);
83: DTRSM dtrsm = new DTRSM(lsame, xerbla);
84: ILAENV ilaenv = new ILAENV(ieeeck, iparmq);
85: DGETRF dgetrf = new DGETRF(dgemm, dgetf2, dlaswp, dtrsm, xerbla, ilaenv);
86: DGETRS dgetrs = new DGETRS(lsame, dlaswp, dtrsm, xerbla);
87:
88: #endregion
89:
90:
91: #region Set Dependencies
92:
93: this._dgetrf = dgetrf; this._dgetrs = dgetrs; this._xerbla = xerbla;
94:
95: #endregion
96:
97: }
98: /// <summary>
99: /// Purpose
100: /// =======
101: ///
102: /// DGESV computes the solution to a real system of linear equations
103: /// A * X = B,
104: /// where A is an N-by-N matrix and X and B are N-by-NRHS matrices.
105: ///
106: /// The LU decomposition with partial pivoting and row interchanges is
107: /// used to factor A as
108: /// A = P * L * U,
109: /// where P is a permutation matrix, L is unit lower triangular, and U is
110: /// upper triangular. The factored form of A is then used to solve the
111: /// system of equations A * X = B.
112: ///
113: ///</summary>
114: /// <param name="N">
115: /// (input) INTEGER
116: /// The number of linear equations, i.e., the order of the
117: /// matrix A. N .GE. 0.
118: ///</param>
119: /// <param name="NRHS">
120: /// (input) INTEGER
121: /// The number of right hand sides, i.e., the number of columns
122: /// of the matrix B. NRHS .GE. 0.
123: ///</param>
124: /// <param name="A">
125: /// (input/output) DOUBLE PRECISION array, dimension (LDA,N)
126: /// On entry, the N-by-N coefficient matrix A.
127: /// On exit, the factors L and U from the factorization
128: /// A = P*L*U; the unit diagonal elements of L are not stored.
129: ///</param>
130: /// <param name="LDA">
131: /// (input) INTEGER
132: /// The leading dimension of the array A. LDA .GE. max(1,N).
133: ///</param>
134: /// <param name="IPIV">
135: /// (output) INTEGER array, dimension (N)
136: /// The pivot indices that define the permutation matrix P;
137: /// row i of the matrix was interchanged with row IPIV(i).
138: ///</param>
139: /// <param name="B">
140: /// (input/output) DOUBLE PRECISION array, dimension (LDB,NRHS)
141: /// On entry, the N-by-NRHS matrix of right hand side matrix B.
142: /// On exit, if INFO = 0, the N-by-NRHS solution matrix X.
143: ///</param>
144: /// <param name="LDB">
145: /// (input) INTEGER
146: /// The leading dimension of the array B. LDB .GE. max(1,N).
147: ///</param>
148: /// <param name="INFO">
149: /// (output) INTEGER
150: /// = 0: successful exit
151: /// .LT. 0: if INFO = -i, the i-th argument had an illegal value
152: /// .GT. 0: if INFO = i, U(i,i) is exactly zero. The factorization
153: /// has been completed, but the factor U is exactly
154: /// singular, so the solution could not be computed.
155: ///</param>
156: public void Run(int N, int NRHS, ref double[] A, int offset_a, int LDA, ref int[] IPIV, int offset_ipiv, ref double[] B, int offset_b
157: , int LDB, ref int INFO)
158: {
159:
160: #region Array Index Correction
161:
162: int o_a = -1 - LDA + offset_a; int o_ipiv = -1 + offset_ipiv; int o_b = -1 - LDB + offset_b;
163:
164: #endregion
165:
166:
167: #region Prolog
168:
169: // *
170: // * -- LAPACK driver routine (version 3.1) --
171: // * Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..
172: // * November 2006
173: // *
174: // * .. Scalar Arguments ..
175: // * ..
176: // * .. Array Arguments ..
177: // * ..
178: // *
179: // * Purpose
180: // * =======
181: // *
182: // * DGESV computes the solution to a real system of linear equations
183: // * A * X = B,
184: // * where A is an N-by-N matrix and X and B are N-by-NRHS matrices.
185: // *
186: // * The LU decomposition with partial pivoting and row interchanges is
187: // * used to factor A as
188: // * A = P * L * U,
189: // * where P is a permutation matrix, L is unit lower triangular, and U is
190: // * upper triangular. The factored form of A is then used to solve the
191: // * system of equations A * X = B.
192: // *
193: // * Arguments
194: // * =========
195: // *
196: // * N (input) INTEGER
197: // * The number of linear equations, i.e., the order of the
198: // * matrix A. N >= 0.
199: // *
200: // * NRHS (input) INTEGER
201: // * The number of right hand sides, i.e., the number of columns
202: // * of the matrix B. NRHS >= 0.
203: // *
204: // * A (input/output) DOUBLE PRECISION array, dimension (LDA,N)
205: // * On entry, the N-by-N coefficient matrix A.
206: // * On exit, the factors L and U from the factorization
207: // * A = P*L*U; the unit diagonal elements of L are not stored.
208: // *
209: // * LDA (input) INTEGER
210: // * The leading dimension of the array A. LDA >= max(1,N).
211: // *
212: // * IPIV (output) INTEGER array, dimension (N)
213: // * The pivot indices that define the permutation matrix P;
214: // * row i of the matrix was interchanged with row IPIV(i).
215: // *
216: // * B (input/output) DOUBLE PRECISION array, dimension (LDB,NRHS)
217: // * On entry, the N-by-NRHS matrix of right hand side matrix B.
218: // * On exit, if INFO = 0, the N-by-NRHS solution matrix X.
219: // *
220: // * LDB (input) INTEGER
221: // * The leading dimension of the array B. LDB >= max(1,N).
222: // *
223: // * INFO (output) INTEGER
224: // * = 0: successful exit
225: // * < 0: if INFO = -i, the i-th argument had an illegal value
226: // * > 0: if INFO = i, U(i,i) is exactly zero. The factorization
227: // * has been completed, but the factor U is exactly
228: // * singular, so the solution could not be computed.
229: // *
230: // * =====================================================================
231: // *
232: // * .. External Subroutines ..
233: // * ..
234: // * .. Intrinsic Functions ..
235: // INTRINSIC MAX;
236: // * ..
237: // * .. Executable Statements ..
238: // *
239: // * Test the input parameters.
240: // *
241:
242: #endregion
243:
244:
245: #region Body
246:
247: INFO = 0;
248: if (N < 0)
249: {
250: INFO = - 1;
251: }
252: else
253: {
254: if (NRHS < 0)
255: {
256: INFO = - 2;
257: }
258: else
259: {
260: if (LDA < Math.Max(1, N))
261: {
262: INFO = - 4;
263: }
264: else
265: {
266: if (LDB < Math.Max(1, N))
267: {
268: INFO = - 7;
269: }
270: }
271: }
272: }
273: if (INFO != 0)
274: {
275: this._xerbla.Run("DGESV ", - INFO);
276: return;
277: }
278: // *
279: // * Compute the LU factorization of A.
280: // *
281: this._dgetrf.Run(N, N, ref A, offset_a, LDA, ref IPIV, offset_ipiv, ref INFO);
282: if (INFO == 0)
283: {
284: // *
285: // * Solve the system A*X = B, overwriting B with X.
286: // *
287: this._dgetrs.Run("No transpose", N, NRHS, A, offset_a, LDA, IPIV, offset_ipiv
288: , ref B, offset_b, LDB, ref INFO);
289: }
290: return;
291: // *
292: // * End of DGESV
293: // *
294:
295: #endregion
296:
297: }
298: }
299: }