Annotation of OpenXM_contrib/TiGERS_0.9/Rsimp.c, Revision 1.1.1.1
1.1 maekawa 1: /*
2: ** Rsimp.c Birk Huber, 4/99
3: ** -- definitions of linear programming data structure and
4: ** -- basic implementation of revised simplex method.
5: **
6: **
7: ** TiGERS, Toric Groebner Basis Enumeration by Reverse Search
8: ** copyright (c) 1999 Birk Huber
9: **
10: */
11: #include <stdio.h>
12: #include <math.h>
13: #define RSIMP_H 1
14: #include "matrices.h"
15: #include "Rsimp.h"
16: #define verbose 0
17: #define zero_tol RS_zt
18:
19: int LP_MAX_N=0,LP_MAX_M=0;
20: int LP_N=0, LP_M=0;
21: double **LP_A=0;
22: double *LP_B=0;
23: double *LP_C=0;
24: double *LP_X=0;
25: int *LP_Basis=0;
26: int *LP_NonBasis=0;
27: double **LP_Q=0;
28: double **LP_R=0;
29: double *LP_t1=0;
30: double *LP_t2=0;
31: double RS_zt=0.0000001;
32:
33:
34: #define basis0(j) (basis[j])
35: #define nonbasis0(j) (nonbasis[j])
36: #define AN0(i,j) (A[nonbasis0(j)][i])
37: #define AB0(i,j) (A[basis0(j)][i])
38: #define CB0(i) (c[basis0(i)])
39: #define CN0(i) (c[nonbasis0(i)])
40: #define XB0(i) (x[basis0(i)])
41: #define XN0(i) (x[nonbasis0(i)])
42: #define Y0(i) (t1[i])
43: #define W0(i) (t2[i])
44: #define D0(i) (t2[i])
45: #define R0(i,j) (R[j][i])
46: #define Q0(i,j) (Q[i][j])
47:
48:
49: /*
50: ** void LP_free_space():
51: ** deallocate space for LP data structures.
52: ** set all LP globals to 0.
53: **
54: */
55: void LP_free_space(){
56: free_matrix(LP_A);
57: free_matrix(LP_Q);
58: free_matrix(LP_R);
59: free_vector(LP_B);
60: free_vector(LP_C);
61: free_vector(LP_X);
62: free_ivector(LP_Basis);
63: free_ivector(LP_NonBasis);
64: free_vector(LP_t1);
65: free_vector(LP_t2);
66: LP_M=LP_N=LP_MAX_M=LP_N=0;
67: LP_A=LP_Q=LP_R=0;
68: LP_B =LP_C=LP_X=LP_t1=LP_t2=0;
69: LP_Basis=LP_NonBasis = 0;
70: }
71:
72: /*
73: ** void LP_get_space(int M, int N):
74: ** allocate space for LP data structures.
75: **
76: */
77: void LP_get_space(int M, int N){
78: if (M>LP_MAX_M || N>LP_MAX_N){
79: LP_free_space();
80: LP_A=new_matrix(M,N);
81: LP_Q=new_matrix(M,M);
82: LP_R=new_matrix(M,N);
83: LP_B = new_vector(M);
84: LP_C = new_vector(N);
85: LP_X = new_vector(N);
86: LP_Basis=new_ivector(M);
87: LP_NonBasis = new_ivector(N-M);
88: LP_t1=new_vector(N);
89: LP_t2=new_vector(N);
90: LP_MAX_M=M;
91: LP_MAX_N=N;
92: }
93: LP_M=M;
94: LP_N=N;
95: }
96:
97: /*
98: ** void Print_LP():
99: ** print LP data structures to stdout.
100: **
101: */
102: void Print_LP(){
103: int i,j;
104: fprintf(stdout,"LP_C \n ");
105: for(i=0;i<LP_N;i++)fprintf(stdout," %f ;", LP_C[i] );
106: fprintf(stdout,"\nLP_A | LP_B\n");
107: for(j=0;j<LP_M;j++) {
108: for(i=0;i<LP_N;i++) fprintf(stdout," %f ",LP_A(j,i));
109: fprintf(stdout,"%f \n",LP_B[j]);
110: }
111: fprintf(stdout, "LP_X \n ");
112: for(i=0;i<LP_N;i++) fprintf(stdout," %f ",LP_X[i]);
113: fprintf(stdout, "\nLP_Basis \n ");
114: for(i=0;i<LP_M;i++) fprintf(stdout," %d ", LP_Basis[i]);
115: fprintf(stdout,"\nLP_LP_NonBasis \n ");
116: for(i=0;i<LP_N-LP_M;i++) fprintf(stdout," %d ",LP_NonBasis[i]);
117: fprintf(stdout,"\n\n");
118: }
119:
120: /*
121: **
122: **int Rsimp(m,n,A,b,c,x,basis,nonbasis,R,Q,t1,t2):
123: ** revised simplex method (Using Bland's rule)
124: ** and a qr factorization to solve the linear equations
125: **
126: ** Adapted from algorithms presented in
127: ** Linear Approximations and Extensions
128: ** (theory and algorithms)
129: ** Fang & Puthenpura
130: ** Prentice Hall, Engelwood Cliffs NJ (1993)
131: ** and
132: ** Linear Programming
133: ** Chvatal
134: ** Freeman and Company, New York, 1983
135: **
136: ** (developed first in Octave, many thanks to the author)
137: **
138: **
139: ** Solve the problem
140: ** minimize C'x,
141: ** subject to A*x=b, x>=0
142: ** for x,c,b n-vectors, and A an m,n matrix with full row rank
143: **
144: ** Assumptions:
145: ** A mxn matrix with full row rank.
146: ** b an m matrix.
147: ** c an n-vector.
148: ** x an n-vector holding a basic feasible solution,
149: ** basis m-vector holding indices of the basic variables in x
150: ** nonbasis n-m vector holding the indices not appearing in x.
151: **
152: ** Returns:
153: ** LP_FAIL if algorithm doesn't terminate.
154: ** LP_UNBD if problem is unbounded
155: ** LP_OPT if optimum found
156: ** efects:
157: ** A,b,c unchanged.
158: ** x basis, nonbasis, hold info describing last basic feasible
159: ** solution.
160: ** Q,R hold qrdecomp of last basis matrix.
161: ** t1,t2 undefined.
162: **
163: **
164: */
165:
166: int Rsimp(int m, int n, double **A, double *b, double *c,
167: double *x, int *basis, int *nonbasis,
168: double **R, double **Q, double *t1, double *t2){
169: int i,j,k,l,q,qv;
170: int max_steps=20;
171: double r,a,at;
172: int ll;
173: void GQR(int,int,double**,double**);
174: max_steps=4*n;
175:
176: for(k=0; k<=max_steps;k++){
177: /*
178: ++ Step 0) load new basis matrix and factor it
179: */
180: for(i=0;i<m;i++)for(j=0;j<m;j++)R0(i,j)=AB0(i,j);
181: GQR(m,m,Q,R);
182:
183: /*
184: ++ Step 1) solving system B'*w=c(basis)
185: ++ a) forward solve R'*y=c(basis)
186: */
187: for(i=0;i<m;i++){
188: Y0(i)=0.0;
189: for(j=0;j<i;j++)Y0(i)+=R0(j,i)*Y0(j);
190: if (R0(i,i)!=0.0) Y0(i)=(CB0(i)-Y0(i))/R0(i,i);
191: else {
192: printf("Warning Singular Matrix Found\n");
193: return LP_FAIL;
194: }
195: }
196: /*
197: ++ b) find w=Q*y
198: ++ note: B'*w=(Q*R)'*Q*y= R'*(Q'*Q)*y=R'*y=c(basis)
199: */
200: for(i=0;i<m;i++){
201: W0(i)=0.0;
202: for(j=0;j<m;j++)W0(i)+=Q0(i,j)*Y0(j);
203: }
204:
205: /*
206: ++ Step 2)find entering variable,
207: ++ (use lexicographically first variable with negative reduced cost)
208: */
209: q=n;
210: for(i=0;i<n-m;i++){
211: /* calculate reduced cost */
212: r=CN0(i);
213: for(j=0;j<m;j++) r-=W0(j)*AN0(j,i);
214: if (r<-zero_tol && (q==n || nonbasis0(i)<nonbasis0(q))) q=i;
215: }
216:
217: /*
218: ++ if ratios were all nonnegative current solution is optimal
219: */
220: if (q==n){
221: if (verbose>0) printf("optimal solution found in %d iterations\n",k);
222: return LP_OPT;
223: }
224: /*
225: ++ Step 3)Calculate translation direction for q entering
226: ++ by solving system B*d=-A(:,nonbasis(q));
227: ++ a) let y=-Q'*A(:,nonbasis(q));
228: */
229: for(i=0;i<m;i++){
230: Y0(i)=0.0;
231: for(j=0;j<m;j++) Y0(i)-=Q0(j,i)*AN0(j,q);
232: }
233:
234: /*
235: ++ b) back solve Rd=y (d=R\y)
236: ++ note B*d= Q*R*d=Q*y=Q*-Q'*A(:nonbasis(q))=-A(:,nonbasis(q))
237: */
238: for(i=m-1;i>=0;i--){
239: D0(i)=0.0;
240: for(j=m-1;j>=i+1;j--)D0(i)+=R0(i,j)*D0(j);
241: if (R0(i,i)!=0.0) D0(i)=(Y0(i)-D0(i))/R0(i,i);
242: else {
243: printf("Warning Singular Matrix Found\n");
244: return LP_FAIL;
245: }
246: }
247: /*
248: ++ Step 4 Choose leaving variable
249: ++ (first variable to become negative, by moving in direction D)
250: ++ (if none become negative, then objective function unbounded)
251: */
252: a=0;
253: l=-1;
254: for(i=0;i<m;i++){
255: if (D0(i)<-zero_tol){
256: at=-1*XB0(i)/D0(i);
257: if (l==-1 || at<a){ a=at; l=i;}
258: }
259: }
260: if (l==-1){
261: if (verbose>0){
262: printf("Objective function Unbounded (%d iterations)\n",k);
263: }
264: return LP_UNBD;
265: }
266: /*
267: ++ Step 5) Update solution and basis data
268: */
269: XN0(q)=a;
270: for(j=0;j<m;j++) XB0(j)+=a*D0(j);
271: XB0(l)=0.0; /* enforce strict zeroness of nonbasis variables */
272: qv=nonbasis0(q);
273: nonbasis0(q)=basis0(l);
274: basis0(l)=qv;
275: }
276: if (verbose>=0){
277: printf("Simplex Algorithm did not Terminate in %d iterations\n",k);
278: }
279: return LP_FAIL;
280: }
281:
282:
283: /*
284: **void GQR(int r, int c, double **Q, double **R):
285: ** Use givens rotations on R to bring it into triangular form.
286: ** Store orthogonal matrix needed to bring R to triangular form in Q.
287: ** Assume R is an rxc matrix and Q is rxr.
288: ** (Question: is r>=c needed ?)
289: **
290: */
291: void GQR(int r, int c, double **Q, double **R){
292: int i,j,k;
293: double s,s1,s2;
294: double t1,t2;
295:
296: for(i=0;i<r;i++){
297: for(k=0;k<r;k++)Q0(i,k)=0.0;
298: Q0(i,i)=1.0;
299: }
300:
301: for (i=0;i<c;i++)
302: for (k=i+1;k<r;k++)
303: /* performing givens rotations to zero A[k][i] */
304: if (R0(k,i)!=0){
305: s=sqrt(R0(i,i)*R0(i,i)+R0(k,i)*R0(k,i));
306: s1=R0(i,i)/s;
307: s2=R0(k,i)/s;
308: for(j=0;j<c;j++) {
309: t1=R0(i,j);
310: t2=R0(k,j);
311: R0(i,j)=s1*t1+s2*t2;
312: R0(k,j)=-s2*t1+s1*t2;
313: }
314: /* actually doing givens row rotations on Q */
315: for(j=0;j<r;j++){
316: t1=Q0(j,i);
317: t2=Q0(j,k);
318: Q0(j,i)=s1*t1+s2*t2;
319: Q0(j,k)=-s2*t1+s1*t2;
320: }
321: }
322:
323: }
324:
325:
326:
327:
328:
329:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to Rsimp.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / TiGERS_0.9