/[escript]/trunk/paso/src/SystemMatrix_MatrixVector.c
ViewVC logotype

Diff of /trunk/paso/src/SystemMatrix_MatrixVector.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

trunk/esys2/paso/src/SystemMatrix_MatrixVector.c revision 150 by jgs, Thu Sep 15 03:44:45 2005 UTC trunk/paso/src/SystemMatrix_MatrixVector.c revision 495 by gross, Mon Feb 6 06:32:06 2006 UTC
# Line 27  void  Paso_SystemMatrix_MatrixVector(dou Line 27  void  Paso_SystemMatrix_MatrixVector(dou
27      double beta,      double beta,
28      double* out) {      double* out) {
29    
30      if (A->type & MATRIX_FORMAT_CSC) {
31         if (A->type & MATRIX_FORMAT_OFFSET1) {
32           Paso_SystemMatrix_MatrixVector_CSC_OFFSET1(alpha,A,in,beta,out);
33         } else {
34           Paso_SystemMatrix_MatrixVector_CSC_OFFSET0(alpha,A,in,beta,out);
35         }
36      } else {
37         if (A->type & MATRIX_FORMAT_OFFSET1) {
38           Paso_SystemMatrix_MatrixVector_CSR_OFFSET1(alpha,A,in,beta,out);
39         } else {
40           Paso_SystemMatrix_MatrixVector_CSR_OFFSET0(alpha,A,in,beta,out);
41         }
42      }
43      return;
44    }
45    
46    void  Paso_SystemMatrix_MatrixVector_CSC_OFFSET0(double alpha,
47        Paso_SystemMatrix* A,
48        double* in,
49        double beta,
50        double* out) {
51    
52      register index_t ir,icol,iptr,icb,irb,irow,ic;
53      register double reg,reg1,reg2,reg3;
54      #pragma omp barrier
55    
56      if (ABS(beta)>0.) {
57        #pragma omp for private(irow) schedule(static)
58        for (irow=0;irow < A->num_rows * A->row_block_size;irow++)
59          out[irow] *= beta;
60      } else {
61        #pragma omp for private(irow) schedule(static)
62        for (irow=0;irow < A->num_rows * A->row_block_size;irow++)
63          out[irow] = 0;
64      }
65          
66      /*  do the operation: */
67      if (ABS(alpha)>0) {
68        if (A ->col_block_size==1 && A->row_block_size ==1) {
69            /* TODO: parallelize (good luck!) */
70            #pragma omp single
71        for (icol=0;icol< A->pattern->n_ptr;++icol) {
72          for (iptr=A->pattern->ptr[icol];iptr<A->pattern->ptr[icol+1]; ++iptr) {
73            out[A->pattern->index[iptr]]+= alpha * A->val[iptr] * in[icol];
74          }
75        }
76        } else if (A ->col_block_size==2 && A->row_block_size ==2) {
77            /* TODO: parallelize */
78            #pragma omp single
79        for (ic=0;ic< A->pattern->n_ptr;ic++) {
80          for (iptr=A->pattern->ptr[ic];iptr<A->pattern->ptr[ic+1]; iptr++) {
81               ic=2*(A->pattern->index[iptr]);
82               out[  2*ir] += alpha * ( A->val[iptr*4  ]*in[ic] + A->val[iptr*4+2]*in[1+ic] );
83               out[1+2*ir] += alpha * ( A->val[iptr*4+1]*in[ic] + A->val[iptr*4+3]*in[1+ic] );
84          }
85        }
86        } else if (A ->col_block_size==3 && A->row_block_size ==3) {
87            /* TODO: parallelize */
88            #pragma omp single
89        for (ic=0;ic< A->pattern->n_ptr;ic++) {
90          for (iptr=A->pattern->ptr[ic];iptr<A->pattern->ptr[ic+1]; iptr++) {
91              ir=3*(A->pattern->index[iptr]);
92                  out[  3*ir] += alpha * ( A->val[iptr*9  ]*in[ic] + A->val[iptr*9+3]*in[1+ic] + A->val[iptr*9+6]*in[2+ic] );
93              out[1+3*ir] += alpha * ( A->val[iptr*9+1]*in[ic] + A->val[iptr*9+4]*in[1+ic] + A->val[iptr*9+7]*in[2+ic] );
94              out[2+3*ir] += alpha * ( A->val[iptr*9+2]*in[ic] + A->val[iptr*9+5]*in[1+ic] + A->val[iptr*9+8]*in[2+ic] );
95          }
96        }
97        } else {
98            /* TODO: parallelize */
99            #pragma omp single
100        for (ic=0;ic< A->pattern->n_ptr;ic++) {
101          for (iptr=A->pattern->ptr[ic];iptr<A->pattern->ptr[ic+1]; iptr++) {
102            for (irb=0;irb< A->row_block_size;irb++) {
103              irow=irb+A->row_block_size*(A->pattern->index[iptr]);
104              for (icb=0;icb< A->col_block_size;icb++) {
105            icol=icb+A->col_block_size*ic;
106            out[irow] += alpha * A->val[iptr*A->block_size+irb+A->row_block_size*icb] * in[icol];
107              }
108            }
109          }
110        }
111        }
112      }
113      return;
114    }
115    
116    void  Paso_SystemMatrix_MatrixVector_CSC_OFFSET1(double alpha,
117        Paso_SystemMatrix* A,
118        double* in,
119        double beta,
120        double* out) {
121    
122    register index_t ir,icol,iptr,icb,irb,irow,ic;    register index_t ir,icol,iptr,icb,irb,irow,ic;
123    register double reg,reg1,reg2,reg3;    register double reg,reg1,reg2,reg3;
124    #pragma omp barrier    #pragma omp barrier
# Line 44  void  Paso_SystemMatrix_MatrixVector(dou Line 136  void  Paso_SystemMatrix_MatrixVector(dou
136    /*  do the operation: */    /*  do the operation: */
137    if (ABS(alpha)>0) {    if (ABS(alpha)>0) {
138      if (A ->col_block_size==1 && A->row_block_size ==1) {      if (A ->col_block_size==1 && A->row_block_size ==1) {
139        switch(A->type) {          /* TODO: parallelize (good luck!) */
140        case CSR:          #pragma omp single
141        for (icol=0;icol< A->pattern->n_ptr;++icol) {
142          for (iptr=A->pattern->ptr[icol]-1;iptr<A->pattern->ptr[icol+1]-1; ++iptr) {
143            out[A->pattern->index[iptr]-1]+= alpha * A->val[iptr] * in[icol];
144          }
145        }
146        } else if (A ->col_block_size==2 && A->row_block_size ==2) {
147            /* TODO: parallelize */
148            #pragma omp single
149        for (ic=0;ic< A->pattern->n_ptr;ic++) {
150          for (iptr=A->pattern->ptr[ic]-1;iptr<A->pattern->ptr[ic+1]-1; iptr++) {
151               ic=2*(A->pattern->index[iptr]-1);
152               out[  2*ir] += alpha * ( A->val[iptr*4  ]*in[ic] + A->val[iptr*4+2]*in[1+ic] );
153               out[1+2*ir] += alpha * ( A->val[iptr*4+1]*in[ic] + A->val[iptr*4+3]*in[1+ic] );
154          }
155        }
156        } else if (A ->col_block_size==3 && A->row_block_size ==3) {
157            /* TODO: parallelize */
158            #pragma omp single
159        for (ic=0;ic< A->pattern->n_ptr;ic++) {
160          for (iptr=A->pattern->ptr[ic]-1;iptr<A->pattern->ptr[ic+1]-1; iptr++) {
161              ir=3*(A->pattern->index[iptr]-1);
162                  out[  3*ir] += alpha * ( A->val[iptr*9  ]*in[ic] + A->val[iptr*9+3]*in[1+ic] + A->val[iptr*9+6]*in[2+ic] );
163              out[1+3*ir] += alpha * ( A->val[iptr*9+1]*in[ic] + A->val[iptr*9+4]*in[1+ic] + A->val[iptr*9+7]*in[2+ic] );
164              out[2+3*ir] += alpha * ( A->val[iptr*9+2]*in[ic] + A->val[iptr*9+5]*in[1+ic] + A->val[iptr*9+8]*in[2+ic] );
165          }
166        }
167        } else {
168            /* TODO: parallelize */
169            #pragma omp single
170        for (ic=0;ic< A->pattern->n_ptr;ic++) {
171          for (iptr=A->pattern->ptr[ic]-1;iptr<A->pattern->ptr[ic+1]-1; iptr++) {
172            for (irb=0;irb< A->row_block_size;irb++) {
173              irow=irb+A->row_block_size*(A->pattern->index[iptr]-1);
174              for (icb=0;icb< A->col_block_size;icb++) {
175            icol=icb+A->col_block_size*ic;
176            out[irow] += alpha * A->val[iptr*A->block_size+irb+A->row_block_size*icb] * in[icol];
177              }
178            }
179          }
180        }
181        }
182      }
183      return;
184    }
185    
186    void  Paso_SystemMatrix_MatrixVector_CSR_OFFSET0(double alpha,
187        Paso_SystemMatrix* A,
188        double* in,
189        double beta,
190        double* out) {
191    
192      register index_t ir,icol,iptr,icb,irb,irow,ic,Aiptr;
193      register double reg,reg1,reg2,reg3,in1,in2,in3,A00,A10,A20,A01,A11,A21,A02,A12,A22;
194      #pragma omp barrier
195      if (ABS(beta)>0.) {
196        #pragma omp for private(irow) schedule(static)
197        for (irow=0;irow < A->num_rows * A->row_block_size;irow++)
198          out[irow] *= beta;
199      } else {
200        #pragma omp for private(irow) schedule(static)
201        for (irow=0;irow < A->num_rows * A->row_block_size;irow++)
202          out[irow] = 0;
203      }
204      /*  do the operation: */
205      if (ABS(alpha)>0) {
206        if (A ->col_block_size==1 && A->row_block_size ==1) {
207          #pragma omp for private(irow,iptr,reg) schedule(static)          #pragma omp for private(irow,iptr,reg) schedule(static)
208      for (irow=0;irow< A->pattern->n_ptr;++irow) {      for (irow=0;irow< A->pattern->n_ptr;++irow) {
209            reg=0.;            reg=0.;
210        for (iptr=(A->pattern->ptr[irow])-PTR_OFFSET;iptr<(A->pattern->ptr[irow+1])-PTR_OFFSET; ++iptr) {            #pragma swp
211            reg += A->val[iptr] * in[A->pattern->index[iptr]-INDEX_OFFSET];        for (iptr=(A->pattern->ptr[irow]);iptr<(A->pattern->ptr[irow+1]); ++iptr) {
212              reg += A->val[iptr] * in[A->pattern->index[iptr]];
213        }        }
214        out[irow] += alpha * reg;        out[irow] += alpha * reg;
215      }      }
216      break;      } else if (A ->col_block_size==2 && A->row_block_size ==2) {
217        case CSC:          #pragma omp for private(ir,iptr,irb,icb,irow,icol,reg1,reg2,in1,in2,Aiptr,A00,A10,A01,A11) schedule(static)
218          /* TODO: parallelize (good luck!) */      for (ir=0;ir< A->pattern->n_ptr;ir++) {
219          #pragma omp single            reg1=0.;
220      for (icol=0;icol< A->pattern->n_ptr;++icol) {            reg2=0.;
221        for (iptr=A->pattern->ptr[icol]-PTR_OFFSET;iptr<A->pattern->ptr[icol+1]-PTR_OFFSET; ++iptr) {            #pragma swp
222          out[A->pattern->index[iptr]-INDEX_OFFSET]+= alpha * A->val[iptr] * in[icol];        for (iptr=A->pattern->ptr[ir];iptr<A->pattern->ptr[ir+1]; iptr++) {
223               ic=2*(A->pattern->index[iptr]);
224                   Aiptr=iptr*4;
225                   in1=in[ic];
226                   in2=in[1+ic];
227                   A00=A->val[Aiptr  ];
228                   A10=A->val[Aiptr+1];
229                   A01=A->val[Aiptr+2];
230                   A11=A->val[Aiptr+3];
231               reg1 += A00*in1 + A01*in2;
232               reg2 += A10*in1 + A11*in2;
233        }        }
234          out[  2*ir] += alpha * reg1;
235          out[1+2*ir] += alpha * reg2;
236        }
237        } else if (A ->col_block_size==3 && A->row_block_size ==3) {
238            #pragma omp for private(ir,iptr,irb,icb,irow,icol,reg1,reg2,reg3,in1,in2,in3,Aiptr,A00,A10,A20,A01,A11,A21,A02,A12,A22) schedule(static)
239        for (ir=0;ir< A->pattern->n_ptr;ir++) {
240              reg1=0.;
241              reg2=0.;
242              reg3=0.;
243              #pragma swp
244          for (iptr=A->pattern->ptr[ir];iptr<A->pattern->ptr[ir+1]; iptr++) {
245               ic=3*(A->pattern->index[iptr]);
246                   Aiptr=iptr*9;
247                   in1=in[ic];
248                   in2=in[1+ic];
249                   in3=in[2+ic];
250                   A00=A->val[Aiptr  ];
251                   A10=A->val[Aiptr+1];
252                   A20=A->val[Aiptr+2];
253                   A01=A->val[Aiptr+3];
254                   A11=A->val[Aiptr+4];
255                   A21=A->val[Aiptr+5];
256                   A02=A->val[Aiptr+6];
257                   A12=A->val[Aiptr+7];
258                   A22=A->val[Aiptr+8];
259               reg1 += A00*in1 + A01*in2 + A02*in3;
260               reg2 += A10*in1 + A11*in2 + A12*in3;
261               reg3 += A20*in1 + A21*in2 + A22*in3;
262          }
263          out[  3*ir] += alpha * reg1;
264          out[1+3*ir] += alpha * reg2;
265          out[2+3*ir] += alpha * reg3;
266        }
267        } else {
268            #pragma omp for private(ir,iptr,irb,icb,irow,icol,reg) schedule(static)
269        for (ir=0;ir< A->pattern->n_ptr;ir++) {
270          for (iptr=A->pattern->ptr[ir];iptr<A->pattern->ptr[ir+1]; iptr++) {
271            for (irb=0;irb< A->row_block_size;irb++) {
272              irow=irb+A->row_block_size*ir;
273                  reg=0.;
274              for (icb=0;icb< A->col_block_size;icb++) {
275            icol=icb+A->col_block_size*(A->pattern->index[iptr]);
276            reg += A->val[iptr*A->block_size+irb+A->row_block_size*icb] * in[icol];
277              }
278              out[irow] += alpha * reg;
279            }
280          }
281        }
282        }
283      }
284      return;
285    }
286    
287    void  Paso_SystemMatrix_MatrixVector_CSR_OFFSET1(double alpha,
288        Paso_SystemMatrix* A,
289        double* in,
290        double beta,
291        double* out) {
292    
293      register index_t ir,icol,iptr,icb,irb,irow,ic;
294      register double reg,reg1,reg2,reg3;
295      #pragma omp barrier
296    
297      if (ABS(beta)>0.) {
298        #pragma omp for private(irow) schedule(static)
299        for (irow=0;irow < A->num_rows * A->row_block_size;irow++)
300          out[irow] *= beta;
301      } else {
302        #pragma omp for private(irow) schedule(static)
303        for (irow=0;irow < A->num_rows * A->row_block_size;irow++)
304          out[irow] = 0;
305      }
306      /*  do the operation: */
307      if (ABS(alpha)>0) {
308        if (A ->col_block_size==1 && A->row_block_size ==1) {
309            #pragma omp for private(irow,iptr,reg) schedule(static)
310        for (irow=0;irow< A->pattern->n_ptr;++irow) {
311              reg=0.;
312          for (iptr=(A->pattern->ptr[irow])-1;iptr<(A->pattern->ptr[irow+1])-1; ++iptr) {
313              reg += A->val[iptr] * in[A->pattern->index[iptr]-1];
314          }
315          out[irow] += alpha * reg;
316      }      }
     break;  
       default:  
     Paso_setError(TYPE_ERROR,"Unknown matrix type in MVM.");  
       } /* switch A->type */  
317      } else if (A ->col_block_size==2 && A->row_block_size ==2) {      } else if (A ->col_block_size==2 && A->row_block_size ==2) {
       switch(A->type) {  
       case CSR:  
318          #pragma omp for private(ir,iptr,irb,icb,irow,icol,reg1,reg2) schedule(static)          #pragma omp for private(ir,iptr,irb,icb,irow,icol,reg1,reg2) schedule(static)
319      for (ir=0;ir< A->pattern->n_ptr;ir++) {      for (ir=0;ir< A->pattern->n_ptr;ir++) {
320            reg1=0.;            reg1=0.;
321            reg2=0.;            reg2=0.;
322        for (iptr=A->pattern->ptr[ir]-PTR_OFFSET;iptr<A->pattern->ptr[ir+1]-PTR_OFFSET; iptr++) {        for (iptr=A->pattern->ptr[ir]-1;iptr<A->pattern->ptr[ir+1]-1; iptr++) {
323             ic=2*(A->pattern->index[iptr]-INDEX_OFFSET);             ic=2*(A->pattern->index[iptr]-1);
324             reg1 += A->val[iptr*4  ]*in[ic] + A->val[iptr*4+2]*in[1+ic];             reg1 += A->val[iptr*4  ]*in[ic] + A->val[iptr*4+2]*in[1+ic];
325             reg2 += A->val[iptr*4+1]*in[ic] + A->val[iptr*4+3]*in[1+ic];             reg2 += A->val[iptr*4+1]*in[ic] + A->val[iptr*4+3]*in[1+ic];
326        }        }
327        out[  2*ir] += alpha * reg1;        out[  2*ir] += alpha * reg1;
328        out[1+2*ir] += alpha * reg2;        out[1+2*ir] += alpha * reg2;
329      }      }
     break;  
       case CSC:  
         /* TODO: parallelize */  
         #pragma omp single  
     for (ic=0;ic< A->pattern->n_ptr;ic++) {  
       for (iptr=A->pattern->ptr[ic]-PTR_OFFSET;iptr<A->pattern->ptr[ic+1]-PTR_OFFSET; iptr++) {  
            ic=2*(A->pattern->index[iptr]-INDEX_OFFSET);  
            out[  2*ir] += alpha * ( A->val[iptr*4  ]*in[ic] + A->val[iptr*4+2]*in[1+ic] );  
            out[1+2*ir] += alpha * ( A->val[iptr*4+1]*in[ic] + A->val[iptr*4+3]*in[1+ic] );  
       }  
     }  
       default:  
     Paso_setError(TYPE_ERROR,"Unknown matrix type in MVM.");  
       } /* switch A->type */  
330      } else if (A ->col_block_size==3 && A->row_block_size ==3) {      } else if (A ->col_block_size==3 && A->row_block_size ==3) {
       switch(A->type) {  
       case CSR:  
331          #pragma omp for private(ir,iptr,irb,icb,irow,icol,reg1,reg2,reg3) schedule(static)          #pragma omp for private(ir,iptr,irb,icb,irow,icol,reg1,reg2,reg3) schedule(static)
332      for (ir=0;ir< A->pattern->n_ptr;ir++) {      for (ir=0;ir< A->pattern->n_ptr;ir++) {
333            reg1=0.;            reg1=0.;
334            reg2=0.;            reg2=0.;
335            reg3=0.;            reg3=0.;
336        for (iptr=A->pattern->ptr[ir]-PTR_OFFSET;iptr<A->pattern->ptr[ir+1]-PTR_OFFSET; iptr++) {        for (iptr=A->pattern->ptr[ir]-1;iptr<A->pattern->ptr[ir+1]-1; iptr++) {
337             ic=3*(A->pattern->index[iptr]-INDEX_OFFSET);             ic=3*(A->pattern->index[iptr]-1);
338             reg1 += A->val[iptr*9  ]*in[ic] + A->val[iptr*9+3]*in[1+ic] + A->val[iptr*9+6]*in[2+ic];             reg1 += A->val[iptr*9  ]*in[ic] + A->val[iptr*9+3]*in[1+ic] + A->val[iptr*9+6]*in[2+ic];
339             reg2 += A->val[iptr*9+1]*in[ic] + A->val[iptr*9+4]*in[1+ic] + A->val[iptr*9+7]*in[2+ic];             reg2 += A->val[iptr*9+1]*in[ic] + A->val[iptr*9+4]*in[1+ic] + A->val[iptr*9+7]*in[2+ic];
340             reg3 += A->val[iptr*9+2]*in[ic] + A->val[iptr*9+5]*in[1+ic] + A->val[iptr*9+8]*in[2+ic];             reg3 += A->val[iptr*9+2]*in[ic] + A->val[iptr*9+5]*in[1+ic] + A->val[iptr*9+8]*in[2+ic];
# Line 114  void  Paso_SystemMatrix_MatrixVector(dou Line 343  void  Paso_SystemMatrix_MatrixVector(dou
343        out[1+3*ir] += alpha * reg2;        out[1+3*ir] += alpha * reg2;
344        out[2+3*ir] += alpha * reg3;        out[2+3*ir] += alpha * reg3;
345      }      }
     break;  
       case CSC:  
         /* TODO: parallelize */  
         #pragma omp single  
     for (ic=0;ic< A->pattern->n_ptr;ic++) {  
       for (iptr=A->pattern->ptr[ic]-PTR_OFFSET;iptr<A->pattern->ptr[ic+1]-PTR_OFFSET; iptr++) {  
           ir=3*(A->pattern->index[iptr]-INDEX_OFFSET);  
               out[  3*ir] += alpha * ( A->val[iptr*9  ]*in[ic] + A->val[iptr*9+3]*in[1+ic] + A->val[iptr*9+6]*in[2+ic] );  
           out[1+3*ir] += alpha * ( A->val[iptr*9+1]*in[ic] + A->val[iptr*9+4]*in[1+ic] + A->val[iptr*9+7]*in[2+ic] );  
           out[2+3*ir] += alpha * ( A->val[iptr*9+2]*in[ic] + A->val[iptr*9+5]*in[1+ic] + A->val[iptr*9+8]*in[2+ic] );  
       }  
     }  
       default:  
     Paso_setError(TYPE_ERROR,"Unknown matrix type in MVM.");  
       } /* switch A->type */  
346      } else {      } else {
       switch(A->type) {  
       case CSR:  
347          #pragma omp for private(ir,iptr,irb,icb,irow,icol,reg) schedule(static)          #pragma omp for private(ir,iptr,irb,icb,irow,icol,reg) schedule(static)
348      for (ir=0;ir< A->pattern->n_ptr;ir++) {      for (ir=0;ir< A->pattern->n_ptr;ir++) {
349        for (iptr=A->pattern->ptr[ir]-PTR_OFFSET;iptr<A->pattern->ptr[ir+1]-PTR_OFFSET; iptr++) {        for (iptr=A->pattern->ptr[ir]-1;iptr<A->pattern->ptr[ir+1]-1; iptr++) {
350          for (irb=0;irb< A->row_block_size;irb++) {          for (irb=0;irb< A->row_block_size;irb++) {
351            irow=irb+A->row_block_size*ir;            irow=irb+A->row_block_size*ir;
352                reg=0.;                reg=0.;
353            for (icb=0;icb< A->col_block_size;icb++) {            for (icb=0;icb< A->col_block_size;icb++) {
354          icol=icb+A->col_block_size*(A->pattern->index[iptr]-INDEX_OFFSET);          icol=icb+A->col_block_size*(A->pattern->index[iptr]-1);
355          reg += A->val[iptr*A->block_size+irb+A->row_block_size*icb] * in[icol];          reg += A->val[iptr*A->block_size+irb+A->row_block_size*icb] * in[icol];
356            }            }
357            out[irow] += alpha * reg;            out[irow] += alpha * reg;
358          }          }
359        }        }
360      }      }
     break;  
       case CSC:  
         /* TODO: parallelize */  
         #pragma omp single  
     for (ic=0;ic< A->pattern->n_ptr;ic++) {  
       for (iptr=A->pattern->ptr[ic]-PTR_OFFSET;iptr<A->pattern->ptr[ic+1]-PTR_OFFSET; iptr++) {  
         for (irb=0;irb< A->row_block_size;irb++) {  
           irow=irb+A->row_block_size*(A->pattern->index[iptr]-INDEX_OFFSET);  
           for (icb=0;icb< A->col_block_size;icb++) {  
         icol=icb+A->col_block_size*ic;  
         out[irow] += alpha * A->val[iptr*A->block_size+irb+A->row_block_size*icb] * in[icol];  
           }  
         }  
       }  
     }  
       default:  
     Paso_setError(TYPE_ERROR,"Unknown matrix type in MVM.");  
       } /* switch A->type */  
361      }      }
362    }    }
363    return;    return;
364  }  }
   
365  /*  /*
366   * $Log$   * $Log$
367   * Revision 1.2  2005/09/15 03:44:39  jgs   * Revision 1.2  2005/09/15 03:44:39  jgs

Legend:
Removed from v.150  
changed lines
  Added in v.495

  ViewVC Help
Powered by ViewVC 1.1.26