![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to dist.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib2 / asir2000 / engine|
Return to dist.c CVS log | Up to [local] / OpenXM_contrib2 / asir2000 / engine |
1.1 noro 1: /* $OpenXM: OpenXM/src/asir99/engine/dist.c,v 1.1.1.1 1999/11/10 08:12:26 noro Exp $ */
2: #include "ca.h"
3:
4: #define NV(p) ((p)->nv)
5: #define C(p) ((p)->c)
6:
7: #define ORD_REVGRADLEX 0
8: #define ORD_GRADLEX 1
9: #define ORD_LEX 2
10: #define ORD_BREVGRADLEX 3
11: #define ORD_BGRADLEX 4
12: #define ORD_BLEX 5
13: #define ORD_BREVREV 6
14: #define ORD_BGRADREV 7
15: #define ORD_BLEXREV 8
16: #define ORD_ELIM 9
17:
18: int (*cmpdl)()=cmpdl_revgradlex;
19: int (*primitive_cmpdl[3])() = {cmpdl_revgradlex,cmpdl_gradlex,cmpdl_lex};
20:
21: int dp_nelim,dp_fcoeffs;
22: struct order_spec dp_current_spec;
23: int *dp_dl_work;
24:
25: int has_fcoef(DP);
26: int has_fcoef_p(P);
27:
28: int has_fcoef(f)
29: DP f;
30: {
31: MP t;
32:
33: if ( !f )
34: return 0;
35: for ( t = BDY(f); t; t = NEXT(t) )
36: if ( has_fcoef_p(t->c) )
37: break;
38: return t ? 1 : 0;
39: }
40:
41: int has_fcoef_p(f)
42: P f;
43: {
44: DCP dc;
45:
46: if ( !f )
47: return 0;
48: else if ( NUM(f) )
49: return (NID((Num)f) == N_LM || NID((Num)f) == N_GF2N) ? 1 : 0;
50: else {
51: for ( dc = DC(f); dc; dc = NEXT(dc) )
52: if ( has_fcoef_p(COEF(dc)) )
53: return 1;
54: return 0;
55: }
56: }
57:
58: void initd(spec)
59: struct order_spec *spec;
60: {
61: switch ( spec->id ) {
62: case 2:
63: cmpdl = cmpdl_matrix;
64: dp_dl_work = (int *)MALLOC_ATOMIC(spec->nv*sizeof(int));
65: break;
66: case 1:
67: cmpdl = cmpdl_order_pair;
68: break;
69: default:
70: switch ( spec->ord.simple ) {
71: case ORD_REVGRADLEX:
72: cmpdl = cmpdl_revgradlex; break;
73: case ORD_GRADLEX:
74: cmpdl = cmpdl_gradlex; break;
75: case ORD_BREVGRADLEX:
76: cmpdl = cmpdl_brevgradlex; break;
77: case ORD_BGRADLEX:
78: cmpdl = cmpdl_bgradlex; break;
79: case ORD_BLEX:
80: cmpdl = cmpdl_blex; break;
81: case ORD_BREVREV:
82: cmpdl = cmpdl_brevrev; break;
83: case ORD_BGRADREV:
84: cmpdl = cmpdl_bgradrev; break;
85: case ORD_BLEXREV:
86: cmpdl = cmpdl_blexrev; break;
87: case ORD_ELIM:
88: cmpdl = cmpdl_elim; break;
89: case ORD_LEX: default:
90: cmpdl = cmpdl_lex; break;
91: }
92: break;
93: }
94: dp_current_spec = *spec;
95: }
96:
97: void ptod(vl,dvl,p,pr)
98: VL vl,dvl;
99: P p;
100: DP *pr;
101: {
102: int isconst = 0;
103: int n,i;
104: VL tvl;
105: V v;
106: DL d;
107: MP m;
108: DCP dc;
109: DP r,s,t,u;
110: P x,c;
111:
112: if ( !p )
113: *pr = 0;
114: else {
115: for ( n = 0, tvl = dvl; tvl; tvl = NEXT(tvl), n++ );
116: if ( NUM(p) ) {
117: NEWDL(d,n);
118: NEWMP(m); m->dl = d; C(m) = p; NEXT(m) = 0; MKDP(n,m,*pr); (*pr)->sugar = 0;
119: } else {
120: for ( i = 0, tvl = dvl, v = VR(p);
121: tvl && tvl->v != v; tvl = NEXT(tvl), i++ );
122: if ( !tvl ) {
123: for ( dc = DC(p), s = 0, MKV(v,x); dc; dc = NEXT(dc) ) {
124: ptod(vl,dvl,COEF(dc),&t); pwrp(vl,x,DEG(dc),&c);
125: muldc(vl,t,c,&r); addd(vl,r,s,&t); s = t;
126: }
127: *pr = s;
128: } else {
129: for ( dc = DC(p), s = 0; dc; dc = NEXT(dc) ) {
130: ptod(vl,dvl,COEF(dc),&t);
131: NEWDL(d,n); d->td = QTOS(DEG(dc)); d->d[i] = d->td;
132: NEWMP(m); m->dl = d; C(m) = (P)ONE; NEXT(m) = 0; MKDP(n,m,u); u->sugar = d->td;
133: muld(vl,t,u,&r); addd(vl,r,s,&t); s = t;
134: }
135: *pr = s;
136: }
137: }
138: }
139: if ( !dp_fcoeffs && has_fcoef(*pr) )
140: dp_fcoeffs = 1;
141: }
142:
143: void dtop(vl,dvl,p,pr)
144: VL vl,dvl;
145: DP p;
146: P *pr;
147: {
148: int n,i;
149: DL d;
150: MP m;
151: P r,s,t,u,w;
152: Q q;
153: VL tvl;
154:
155: if ( !p )
156: *pr = 0;
157: else {
158: for ( n = p->nv, m = BDY(p), s = 0; m; m = NEXT(m) ) {
159: t = C(m);
160: if ( NUM(t) && NID((Num)t) == N_M ) {
161: mptop(t,&u); t = u;
162: }
163: for ( i = 0, d = m->dl, tvl = dvl;
164: i < n; tvl = NEXT(tvl), i++ ) {
165: MKV(tvl->v,r); STOQ(d->d[i],q); pwrp(vl,r,q,&u);
166: mulp(vl,t,u,&w); t = w;
167: }
168: addp(vl,s,t,&u); s = u;
169: }
170: *pr = s;
171: }
172: }
173:
174: void nodetod(node,dp)
175: NODE node;
176: DP *dp;
177: {
178: NODE t;
179: int len,i,td;
180: Q e;
181: DL d;
182: MP m;
183: DP u;
184:
185: for ( t = node, len = 0; t; t = NEXT(t), len++ );
186: NEWDL(d,len);
187: for ( t = node, i = 0, td = 0; i < len; t = NEXT(t), i++ ) {
188: e = (Q)BDY(t);
189: if ( !e )
190: d->d[i] = 0;
191: else if ( !NUM(e) || !RATN(e) || !INT(e) )
192: error("nodetod : invalid input");
193: else {
194: d->d[i] = QTOS((Q)e); td += d->d[i];
195: }
196: }
197: d->td = td;
198: NEWMP(m); m->dl = d; C(m) = (P)ONE; NEXT(m) = 0;
199: MKDP(len,m,u); u->sugar = td; *dp = u;
200: }
201:
202: int sugard(m)
203: MP m;
204: {
205: int s;
206:
207: for ( s = 0; m; m = NEXT(m) )
208: s = MAX(s,m->dl->td);
209: return s;
210: }
211:
212: void addd(vl,p1,p2,pr)
213: VL vl;
214: DP p1,p2,*pr;
215: {
216: int n;
217: MP m1,m2,mr,mr0;
218: P t;
219:
220: if ( !p1 )
221: *pr = p2;
222: else if ( !p2 )
223: *pr = p1;
224: else {
225: for ( n = NV(p1), m1 = BDY(p1), m2 = BDY(p2), mr0 = 0; m1 && m2; )
226: switch ( (*cmpdl)(n,m1->dl,m2->dl) ) {
227: case 0:
228: addp(vl,C(m1),C(m2),&t);
229: if ( t ) {
230: NEXTMP(mr0,mr); mr->dl = m1->dl; C(mr) = t;
231: }
232: m1 = NEXT(m1); m2 = NEXT(m2); break;
233: case 1:
234: NEXTMP(mr0,mr); mr->dl = m1->dl; C(mr) = C(m1);
235: m1 = NEXT(m1); break;
236: case -1:
237: NEXTMP(mr0,mr); mr->dl = m2->dl; C(mr) = C(m2);
238: m2 = NEXT(m2); break;
239: }
240: if ( !mr0 )
241: if ( m1 )
242: mr0 = m1;
243: else if ( m2 )
244: mr0 = m2;
245: else {
246: *pr = 0;
247: return;
248: }
249: else if ( m1 )
250: NEXT(mr) = m1;
251: else if ( m2 )
252: NEXT(mr) = m2;
253: else
254: NEXT(mr) = 0;
255: MKDP(NV(p1),mr0,*pr);
256: if ( *pr )
257: (*pr)->sugar = MAX(p1->sugar,p2->sugar);
258: }
259: }
260:
261: /* for F4 symbolic reduction */
262:
263: void symb_addd(p1,p2,pr)
264: DP p1,p2,*pr;
265: {
266: int n;
267: MP m1,m2,mr,mr0;
268: P t;
269:
270: if ( !p1 )
271: *pr = p2;
272: else if ( !p2 )
273: *pr = p1;
274: else {
275: for ( n = NV(p1), m1 = BDY(p1), m2 = BDY(p2), mr0 = 0; m1 && m2; ) {
276: NEXTMP(mr0,mr); C(mr) = (P)ONE;
277: switch ( (*cmpdl)(n,m1->dl,m2->dl) ) {
278: case 0:
279: mr->dl = m1->dl;
280: m1 = NEXT(m1); m2 = NEXT(m2); break;
281: case 1:
282: mr->dl = m1->dl;
283: m1 = NEXT(m1); break;
284: case -1:
285: mr->dl = m2->dl;
286: m2 = NEXT(m2); break;
287: }
288: }
289: if ( !mr0 )
290: if ( m1 )
291: mr0 = m1;
292: else if ( m2 )
293: mr0 = m2;
294: else {
295: *pr = 0;
296: return;
297: }
298: else if ( m1 )
299: NEXT(mr) = m1;
300: else if ( m2 )
301: NEXT(mr) = m2;
302: else
303: NEXT(mr) = 0;
304: MKDP(NV(p1),mr0,*pr);
305: if ( *pr )
306: (*pr)->sugar = MAX(p1->sugar,p2->sugar);
307: }
308: }
309:
310: void subd(vl,p1,p2,pr)
311: VL vl;
312: DP p1,p2,*pr;
313: {
314: DP t;
315:
316: if ( !p2 )
317: *pr = p1;
318: else {
319: chsgnd(p2,&t); addd(vl,p1,t,pr);
320: }
321: }
322:
323: void chsgnd(p,pr)
324: DP p,*pr;
325: {
326: MP m,mr,mr0;
327:
328: if ( !p )
329: *pr = 0;
330: else {
331: for ( mr0 = 0, m = BDY(p); m; m = NEXT(m) ) {
332: NEXTMP(mr0,mr); chsgnp(C(m),&C(mr)); mr->dl = m->dl;
333: }
334: NEXT(mr) = 0; MKDP(NV(p),mr0,*pr);
335: if ( *pr )
336: (*pr)->sugar = p->sugar;
337: }
338: }
339:
340: void muld(vl,p1,p2,pr)
341: VL vl;
342: DP p1,p2,*pr;
343: {
344: MP m;
345: DP s,t,u;
346:
347: if ( !p1 || !p2 )
348: *pr = 0;
349: else if ( OID(p1) <= O_P )
350: muldc(vl,p2,(P)p1,pr);
351: else if ( OID(p2) <= O_P )
352: muldc(vl,p1,(P)p2,pr);
353: else {
354: for ( m = BDY(p2), s = 0; m; m = NEXT(m) ) {
355: muldm(vl,p1,m,&t); addd(vl,s,t,&u); s = u;
356: }
357: *pr = s;
358: }
359: }
360:
361: void muldm(vl,p,m0,pr)
362: VL vl;
363: DP p;
364: MP m0;
365: DP *pr;
366: {
367: MP m,mr,mr0;
368: P c;
369: DL d;
370: int n;
371:
372: if ( !p )
373: *pr = 0;
374: else {
375: for ( mr0 = 0, m = BDY(p), c = C(m0), d = m0->dl, n = NV(p);
376: m; m = NEXT(m) ) {
377: NEXTMP(mr0,mr);
378: if ( NUM(C(m)) && RATN(C(m)) && NUM(c) && RATN(c) )
379: mulq((Q)C(m),(Q)c,(Q *)&C(mr));
380: else
381: mulp(vl,C(m),c,&C(mr));
382: adddl(n,m->dl,d,&mr->dl);
383: }
384: NEXT(mr) = 0; MKDP(NV(p),mr0,*pr);
385: if ( *pr )
386: (*pr)->sugar = p->sugar + m0->dl->td;
387: }
388: }
389:
390: void muldc(vl,p,c,pr)
391: VL vl;
392: DP p;
393: P c;
394: DP *pr;
395: {
396: MP m,mr,mr0;
397:
398: if ( !p || !c )
399: *pr = 0;
400: else if ( NUM(c) && UNIQ((Q)c) )
401: *pr = p;
402: else if ( NUM(c) && MUNIQ((Q)c) )
403: chsgnd(p,pr);
404: else {
405: for ( mr0 = 0, m = BDY(p); m; m = NEXT(m) ) {
406: NEXTMP(mr0,mr);
407: if ( NUM(C(m)) && RATN(C(m)) && NUM(c) && RATN(c) )
408: mulq((Q)C(m),(Q)c,(Q *)&C(mr));
409: else
410: mulp(vl,C(m),c,&C(mr));
411: mr->dl = m->dl;
412: }
413: NEXT(mr) = 0; MKDP(NV(p),mr0,*pr);
414: if ( *pr )
415: (*pr)->sugar = p->sugar;
416: }
417: }
418:
419: void divsdc(vl,p,c,pr)
420: VL vl;
421: DP p;
422: P c;
423: DP *pr;
424: {
425: MP m,mr,mr0;
426:
427: if ( !c )
428: error("disvsdc : division by 0");
429: else if ( !p )
430: *pr = 0;
431: else {
432: for ( mr0 = 0, m = BDY(p); m; m = NEXT(m) ) {
433: NEXTMP(mr0,mr); divsp(vl,C(m),c,&C(mr)); mr->dl = m->dl;
434: }
435: NEXT(mr) = 0; MKDP(NV(p),mr0,*pr);
436: if ( *pr )
437: (*pr)->sugar = p->sugar;
438: }
439: }
440:
441: void adddl(n,d1,d2,dr)
442: int n;
443: DL d1,d2;
444: DL *dr;
445: {
446: DL dt;
447: int i;
448:
449: if ( !d1->td )
450: *dr = d2;
451: else if ( !d2->td )
452: *dr = d1;
453: else {
454: *dr = dt = (DL)MALLOC_ATOMIC((n+1)*sizeof(int));
455: dt->td = d1->td + d2->td;
456: for ( i = 0; i < n; i++ )
457: dt->d[i] = d1->d[i]+d2->d[i];
458: }
459: }
460:
461: int compd(vl,p1,p2)
462: VL vl;
463: DP p1,p2;
464: {
465: int n,t;
466: MP m1,m2;
467:
468: if ( !p1 )
469: return p2 ? -1 : 0;
470: else if ( !p2 )
471: return 1;
472: else {
473: for ( n = NV(p1), m1 = BDY(p1), m2 = BDY(p2);
474: m1 && m2; m1 = NEXT(m1), m2 = NEXT(m2) )
475: if ( (t = (*cmpdl)(n,m1->dl,m2->dl)) ||
476: (t = compp(vl,C(m1),C(m2)) ) )
477: return t;
478: if ( m1 )
479: return 1;
480: else if ( m2 )
481: return -1;
482: else
483: return 0;
484: }
485: }
486:
487: int cmpdl_lex(n,d1,d2)
488: int n;
489: DL d1,d2;
490: {
491: int i;
492:
493: for ( i = 0; i < n && d1->d[i] == d2->d[i]; i++ );
494: return i == n ? 0 : (d1->d[i] > d2->d[i] ? 1 : -1);
495: }
496:
497: int cmpdl_revlex(n,d1,d2)
498: int n;
499: DL d1,d2;
500: {
501: int i;
502:
503: for ( i = n - 1; i >= 0 && d1->d[i] == d2->d[i]; i-- );
504: return i < 0 ? 0 : (d1->d[i] < d2->d[i] ? 1 : -1);
505: }
506:
507: int cmpdl_gradlex(n,d1,d2)
508: int n;
509: DL d1,d2;
510: {
511: if ( d1->td > d2->td )
512: return 1;
513: else if ( d1->td < d2->td )
514: return -1;
515: else
516: return cmpdl_lex(n,d1,d2);
517: }
518:
519: int cmpdl_revgradlex(n,d1,d2)
520: int n;
521: DL d1,d2;
522: {
523: if ( d1->td > d2->td )
524: return 1;
525: else if ( d1->td < d2->td )
526: return -1;
527: else
528: return cmpdl_revlex(n,d1,d2);
529: }
530:
531: int cmpdl_blex(n,d1,d2)
532: int n;
533: DL d1,d2;
534: {
535: int c;
536:
537: if ( c = cmpdl_lex(n-1,d1,d2) )
538: return c;
539: else {
540: c = d1->d[n-1] - d2->d[n-1];
541: return c > 0 ? 1 : c < 0 ? -1 : 0;
542: }
543: }
544:
545: int cmpdl_bgradlex(n,d1,d2)
546: int n;
547: DL d1,d2;
548: {
549: int e1,e2,c;
550:
551: e1 = d1->td - d1->d[n-1]; e2 = d2->td - d2->d[n-1];
552: if ( e1 > e2 )
553: return 1;
554: else if ( e1 < e2 )
555: return -1;
556: else {
557: c = cmpdl_lex(n-1,d1,d2);
558: if ( c )
559: return c;
560: else
561: return d1->td > d2->td ? 1 : d1->td < d2->td ? -1 : 0;
562: }
563: }
564:
565: int cmpdl_brevgradlex(n,d1,d2)
566: int n;
567: DL d1,d2;
568: {
569: int e1,e2,c;
570:
571: e1 = d1->td - d1->d[n-1]; e2 = d2->td - d2->d[n-1];
572: if ( e1 > e2 )
573: return 1;
574: else if ( e1 < e2 )
575: return -1;
576: else {
577: c = cmpdl_revlex(n-1,d1,d2);
578: if ( c )
579: return c;
580: else
581: return d1->td > d2->td ? 1 : d1->td < d2->td ? -1 : 0;
582: }
583: }
584:
585: int cmpdl_brevrev(n,d1,d2)
586: int n;
587: DL d1,d2;
588: {
589: int e1,e2,f1,f2,c,i;
590:
591: for ( i = 0, e1 = 0, e2 = 0; i < dp_nelim; i++ ) {
592: e1 += d1->d[i]; e2 += d2->d[i];
593: }
594: f1 = d1->td - e1; f2 = d2->td - e2;
595: if ( e1 > e2 )
596: return 1;
597: else if ( e1 < e2 )
598: return -1;
599: else {
600: c = cmpdl_revlex(dp_nelim,d1,d2);
601: if ( c )
602: return c;
603: else if ( f1 > f2 )
604: return 1;
605: else if ( f1 < f2 )
606: return -1;
607: else {
608: for ( i = n - 1; i >= dp_nelim && d1->d[i] == d2->d[i]; i-- );
609: return i < dp_nelim ? 0 : (d1->d[i] < d2->d[i] ? 1 : -1);
610: }
611: }
612: }
613:
614: int cmpdl_bgradrev(n,d1,d2)
615: int n;
616: DL d1,d2;
617: {
618: int e1,e2,f1,f2,c,i;
619:
620: for ( i = 0, e1 = 0, e2 = 0; i < dp_nelim; i++ ) {
621: e1 += d1->d[i]; e2 += d2->d[i];
622: }
623: f1 = d1->td - e1; f2 = d2->td - e2;
624: if ( e1 > e2 )
625: return 1;
626: else if ( e1 < e2 )
627: return -1;
628: else {
629: c = cmpdl_lex(dp_nelim,d1,d2);
630: if ( c )
631: return c;
632: else if ( f1 > f2 )
633: return 1;
634: else if ( f1 < f2 )
635: return -1;
636: else {
637: for ( i = n - 1; i >= dp_nelim && d1->d[i] == d2->d[i]; i-- );
638: return i < dp_nelim ? 0 : (d1->d[i] < d2->d[i] ? 1 : -1);
639: }
640: }
641: }
642:
643: int cmpdl_blexrev(n,d1,d2)
644: int n;
645: DL d1,d2;
646: {
647: int e1,e2,f1,f2,c,i;
648:
649: for ( i = 0, e1 = 0, e2 = 0; i < dp_nelim; i++ ) {
650: e1 += d1->d[i]; e2 += d2->d[i];
651: }
652: f1 = d1->td - e1; f2 = d2->td - e2;
653: c = cmpdl_lex(dp_nelim,d1,d2);
654: if ( c )
655: return c;
656: else if ( f1 > f2 )
657: return 1;
658: else if ( f1 < f2 )
659: return -1;
660: else {
661: for ( i = n - 1; i >= dp_nelim && d1->d[i] == d2->d[i]; i-- );
662: return i < dp_nelim ? 0 : (d1->d[i] < d2->d[i] ? 1 : -1);
663: }
664: }
665:
666: int cmpdl_elim(n,d1,d2)
667: int n;
668: DL d1,d2;
669: {
670: int e1,e2,i;
671:
672: for ( i = 0, e1 = 0, e2 = 0; i < dp_nelim; i++ ) {
673: e1 += d1->d[i]; e2 += d2->d[i];
674: }
675: if ( e1 > e2 )
676: return 1;
677: else if ( e1 < e2 )
678: return -1;
679: else
680: return cmpdl_revgradlex(n,d1,d2);
681: }
682:
683: int cmpdl_order_pair(n,d1,d2)
684: int n;
685: DL d1,d2;
686: {
687: int e1,e2,i,j,l;
688: int *t1,*t2;
689: int len;
690: struct order_pair *pair;
691:
692: len = dp_current_spec.ord.block.length;
693: pair = dp_current_spec.ord.block.order_pair;
694:
695: for ( i = 0, t1 = d1->d, t2 = d2->d; i < len; i++ ) {
696: l = pair[i].length;
697: switch ( pair[i].order ) {
698: case 0:
699: for ( j = 0, e1 = e2 = 0; j < l; j++ ) {
700: e1 += t1[j]; e2 += t2[j];
701: }
702: if ( e1 > e2 )
703: return 1;
704: else if ( e1 < e2 )
705: return -1;
706: else {
707: for ( j = l - 1; j >= 0 && t1[j] == t2[j]; j-- );
708: if ( j >= 0 )
709: return t1[j] < t2[j] ? 1 : -1;
710: }
711: break;
712: case 1:
713: for ( j = 0, e1 = e2 = 0; j < l; j++ ) {
714: e1 += t1[j]; e2 += t2[j];
715: }
716: if ( e1 > e2 )
717: return 1;
718: else if ( e1 < e2 )
719: return -1;
720: else {
721: for ( j = 0; j < l && t1[j] == t2[j]; j++ );
722: if ( j < l )
723: return t1[j] > t2[j] ? 1 : -1;
724: }
725: break;
726: case 2:
727: for ( j = 0; j < l && t1[j] == t2[j]; j++ );
728: if ( j < l )
729: return t1[j] > t2[j] ? 1 : -1;
730: break;
731: default:
732: error("cmpdl_order_pair : invalid order"); break;
733: }
734: t1 += l; t2 += l;
735: }
736: return 0;
737: }
738:
739: int cmpdl_matrix(n,d1,d2)
740: int n;
741: DL d1,d2;
742: {
743: int *v,*w,*t1,*t2;
744: int s,i,j,len;
745: int **matrix;
746:
747: for ( i = 0, t1 = d1->d, t2 = d2->d, w = dp_dl_work; i < n; i++ )
748: w[i] = t1[i]-t2[i];
749: len = dp_current_spec.ord.matrix.row;
750: matrix = dp_current_spec.ord.matrix.matrix;
751: for ( j = 0; j < len; j++ ) {
752: v = matrix[j];
753: for ( i = 0, s = 0; i < n; i++ )
754: s += v[i]*w[i];
755: if ( s > 0 )
756: return 1;
757: else if ( s < 0 )
758: return -1;
759: }
760: return 0;
761: }