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 routine (version 3.1) --
21: /// Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..
22: /// November 2006
23: /// Purpose
24: /// =======
25: ///
26: /// DLAMRG will create a permutation list which will merge the elements
27: /// of A (which is composed of two independently sorted sets) into a
28: /// single set which is sorted in ascending order.
29: ///
30: ///</summary>
31: public class DLAMRG
32: {
33:
34:
35: #region Fields
36:
37: int I = 0; int IND1 = 0; int IND2 = 0; int N1SV = 0; int N2SV = 0;
38:
39: #endregion
40:
41: public DLAMRG()
42: {
43:
44: }
45:
46: /// <summary>
47: /// Purpose
48: /// =======
49: ///
50: /// DLAMRG will create a permutation list which will merge the elements
51: /// of A (which is composed of two independently sorted sets) into a
52: /// single set which is sorted in ascending order.
53: ///
54: ///</summary>
55: /// <param name="N1">
56: /// (input) INTEGER
57: ///</param>
58: /// <param name="N2">
59: /// (input) INTEGER
60: /// These arguements contain the respective lengths of the two
61: /// sorted lists to be merged.
62: ///</param>
63: /// <param name="A">
64: /// (input) DOUBLE PRECISION array, dimension (N1+N2)
65: /// The first N1 elements of A contain a list of numbers which
66: /// are sorted in either ascending or descending order. Likewise
67: /// for the final N2 elements.
68: ///</param>
69: /// <param name="DTRD1">
70: /// (input) INTEGER
71: ///</param>
72: /// <param name="DTRD2">
73: /// (input) INTEGER
74: /// These are the strides to be taken through the array A.
75: /// Allowable strides are 1 and -1. They indicate whether a
76: /// subset of A is sorted in ascending (DTRDx = 1) or descending
77: /// (DTRDx = -1) order.
78: ///</param>
79: /// <param name="INDEX">
80: /// (output) INTEGER array, dimension (N1+N2)
81: /// On exit this array will contain a permutation such that
82: /// if B( I ) = A( INDEX( I ) ) for I=1,N1+N2, then B will be
83: /// sorted in ascending order.
84: ///</param>
85: public void Run(int N1, int N2, double[] A, int offset_a, int DTRD1, int DTRD2, ref int[] INDEX, int offset_index)
86: {
87:
88: #region Array Index Correction
89:
90: int o_a = -1 + offset_a; int o_index = -1 + offset_index;
91:
92: #endregion
93:
94:
95: #region Prolog
96:
97: // *
98: // * -- LAPACK routine (version 3.1) --
99: // * Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..
100: // * November 2006
101: // *
102: // * .. Scalar Arguments ..
103: // * ..
104: // * .. Array Arguments ..
105: // * ..
106: // *
107: // * Purpose
108: // * =======
109: // *
110: // * DLAMRG will create a permutation list which will merge the elements
111: // * of A (which is composed of two independently sorted sets) into a
112: // * single set which is sorted in ascending order.
113: // *
114: // * Arguments
115: // * =========
116: // *
117: // * N1 (input) INTEGER
118: // * N2 (input) INTEGER
119: // * These arguements contain the respective lengths of the two
120: // * sorted lists to be merged.
121: // *
122: // * A (input) DOUBLE PRECISION array, dimension (N1+N2)
123: // * The first N1 elements of A contain a list of numbers which
124: // * are sorted in either ascending or descending order. Likewise
125: // * for the final N2 elements.
126: // *
127: // * DTRD1 (input) INTEGER
128: // * DTRD2 (input) INTEGER
129: // * These are the strides to be taken through the array A.
130: // * Allowable strides are 1 and -1. They indicate whether a
131: // * subset of A is sorted in ascending (DTRDx = 1) or descending
132: // * (DTRDx = -1) order.
133: // *
134: // * INDEX (output) INTEGER array, dimension (N1+N2)
135: // * On exit this array will contain a permutation such that
136: // * if B( I ) = A( INDEX( I ) ) for I=1,N1+N2, then B will be
137: // * sorted in ascending order.
138: // *
139: // * =====================================================================
140: // *
141: // * .. Local Scalars ..
142: // * ..
143: // * .. Executable Statements ..
144: // *
145:
146: #endregion
147:
148:
149: #region Body
150:
151: N1SV = N1;
152: N2SV = N2;
153: if (DTRD1 > 0)
154: {
155: IND1 = 1;
156: }
157: else
158: {
159: IND1 = N1;
160: }
161: if (DTRD2 > 0)
162: {
163: IND2 = 1 + N1;
164: }
165: else
166: {
167: IND2 = N1 + N2;
168: }
169: I = 1;
170: // * while ( (N1SV > 0) & (N2SV > 0) )
171: LABEL10:;
172: if (N1SV > 0 && N2SV > 0)
173: {
174: if (A[IND1 + o_a] <= A[IND2 + o_a])
175: {
176: INDEX[I + o_index] = IND1;
177: I = I + 1;
178: IND1 = IND1 + DTRD1;
179: N1SV = N1SV - 1;
180: }
181: else
182: {
183: INDEX[I + o_index] = IND2;
184: I = I + 1;
185: IND2 = IND2 + DTRD2;
186: N2SV = N2SV - 1;
187: }
188: goto LABEL10;
189: }
190: // * end while
191: if (N1SV == 0)
192: {
193: for (N1SV = 1; N1SV <= N2SV; N1SV++)
194: {
195: INDEX[I + o_index] = IND2;
196: I = I + 1;
197: IND2 = IND2 + DTRD2;
198: }
199: }
200: else
201: {
202: // * N2SV .EQ. 0
203: for (N2SV = 1; N2SV <= N1SV; N2SV++)
204: {
205: INDEX[I + o_index] = IND1;
206: I = I + 1;
207: IND1 = IND1 + DTRD1;
208: }
209: }
210: // *
211: return;
212: // *
213: // * End of DLAMRG
214: // *
215:
216: #endregion
217:
218: }
219: }
220: }