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: /// DLARTV applies a vector of real plane rotations to elements of the
27: /// real vectors x and y. For i = 1,2,...,n
28: ///
29: /// ( x(i) ) := ( c(i) s(i) ) ( x(i) )
30: /// ( y(i) ) ( -s(i) c(i) ) ( y(i) )
31: ///
32: ///</summary>
33: public class DLARTV
34: {
35:
36:
37: #region Fields
38:
39: int I = 0; int IC = 0; int IX = 0; int IY = 0; double XI = 0; double YI = 0;
40:
41: #endregion
42:
43: public DLARTV()
44: {
45:
46: }
47:
48: /// <summary>
49: /// Purpose
50: /// =======
51: ///
52: /// DLARTV applies a vector of real plane rotations to elements of the
53: /// real vectors x and y. For i = 1,2,...,n
54: ///
55: /// ( x(i) ) := ( c(i) s(i) ) ( x(i) )
56: /// ( y(i) ) ( -s(i) c(i) ) ( y(i) )
57: ///
58: ///</summary>
59: /// <param name="N">
60: /// (input) INTEGER
61: /// The number of plane rotations to be applied.
62: ///</param>
63: /// <param name="X">
64: /// (input/output) DOUBLE PRECISION array,
65: /// dimension (1+(N-1)*INCX)
66: /// The vector x.
67: ///</param>
68: /// <param name="INCX">
69: /// (input) INTEGER
70: /// The increment between elements of X. INCX .GT. 0.
71: ///</param>
72: /// <param name="Y">
73: /// (input/output) DOUBLE PRECISION array,
74: /// dimension (1+(N-1)*INCY)
75: /// The vector y.
76: ///</param>
77: /// <param name="INCY">
78: /// (input) INTEGER
79: /// The increment between elements of Y. INCY .GT. 0.
80: ///</param>
81: /// <param name="C">
82: /// (input) DOUBLE PRECISION array, dimension (1+(N-1)*INCC)
83: /// The cosines of the plane rotations.
84: ///</param>
85: /// <param name="S">
86: /// (input) DOUBLE PRECISION array, dimension (1+(N-1)*INCC)
87: /// The sines of the plane rotations.
88: ///</param>
89: /// <param name="INCC">
90: /// (input) INTEGER
91: /// The increment between elements of C and S. INCC .GT. 0.
92: ///</param>
93: public void Run(int N, ref double[] X, int offset_x, int INCX, ref double[] Y, int offset_y, int INCY, double[] C, int offset_c
94: , double[] S, int offset_s, int INCC)
95: {
96:
97: #region Array Index Correction
98:
99: int o_x = -1 + offset_x; int o_y = -1 + offset_y; int o_c = -1 + offset_c; int o_s = -1 + offset_s;
100:
101: #endregion
102:
103:
104: #region Prolog
105:
106: // *
107: // * -- LAPACK auxiliary routine (version 3.1) --
108: // * Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..
109: // * November 2006
110: // *
111: // * .. Scalar Arguments ..
112: // * ..
113: // * .. Array Arguments ..
114: // * ..
115: // *
116: // * Purpose
117: // * =======
118: // *
119: // * DLARTV applies a vector of real plane rotations to elements of the
120: // * real vectors x and y. For i = 1,2,...,n
121: // *
122: // * ( x(i) ) := ( c(i) s(i) ) ( x(i) )
123: // * ( y(i) ) ( -s(i) c(i) ) ( y(i) )
124: // *
125: // * Arguments
126: // * =========
127: // *
128: // * N (input) INTEGER
129: // * The number of plane rotations to be applied.
130: // *
131: // * X (input/output) DOUBLE PRECISION array,
132: // * dimension (1+(N-1)*INCX)
133: // * The vector x.
134: // *
135: // * INCX (input) INTEGER
136: // * The increment between elements of X. INCX > 0.
137: // *
138: // * Y (input/output) DOUBLE PRECISION array,
139: // * dimension (1+(N-1)*INCY)
140: // * The vector y.
141: // *
142: // * INCY (input) INTEGER
143: // * The increment between elements of Y. INCY > 0.
144: // *
145: // * C (input) DOUBLE PRECISION array, dimension (1+(N-1)*INCC)
146: // * The cosines of the plane rotations.
147: // *
148: // * S (input) DOUBLE PRECISION array, dimension (1+(N-1)*INCC)
149: // * The sines of the plane rotations.
150: // *
151: // * INCC (input) INTEGER
152: // * The increment between elements of C and S. INCC > 0.
153: // *
154: // * =====================================================================
155: // *
156: // * .. Local Scalars ..
157: // * ..
158: // * .. Executable Statements ..
159: // *
160:
161: #endregion
162:
163: IX = 1;
164: IY = 1;
165: IC = 1;
166: for (I = 1; I <= N; I++)
167: {
168: XI = X[IX + o_x];
169: YI = Y[IY + o_y];
170: X[IX + o_x] = C[IC + o_c] * XI + S[IC + o_s] * YI;
171: Y[IY + o_y] = C[IC + o_c] * YI - S[IC + o_s] * XI;
172: IX = IX + INCX;
173: IY = IY + INCY;
174: IC = IC + INCC;
175: }
176: return;
177: // *
178: // * End of DLARTV
179: // *
180: }
181: }
182: }