source: git/Singular/spSpolyLoop.inc @ 97a7b44

spielwiese
Last change on this file since 97a7b44 was bf53f8, checked in by Hans Schönemann <hannes@…>, 25 years ago
*hannes: fixes for p_.Order git-svn-id: file:///usr/local/Singular/svn/trunk@2763 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 66.4 KB
Line 
1typedef enum Characteristics {chGEN = 0, chMODP} Characteristics;
2typedef enum OrderingTypes {otGEN = 0, otEXP, otCOMPEXP, otEXPCOMP} OrderingTypes;
3typedef enum Homogs {homGEN = 0, homYES} Homogs;
4typedef enum NumWords {nwGEN = 0, nwONE, nwTWO, nwEVEN, nwODD} NumWords;
5static void spSpolyLoop_chMODP_otCOMPEXP_homGEN_nwEVEN
6(poly a1, poly a2, poly monom, poly spNoether)
7{
8  poly a = monom,                         // collects the result
9       b = NULL,                          // stores a1*monom
10       c;                                 // used for temporary storage
11  number tm   = pGetCoeff(monom),         // coefficient of monom
12         tneg = npNegM(tm),        // - (coefficient of monom)
13         tb,                              // used for tm*coeff(a1)
14         tc;                              // used for intermediate coeff
15
16  Order_t order;                          // used for homog case
17
18  if (a2==NULL) goto Finish;              // we are done if a2 is 0
19  b = pNew();   
20
21  ;              // inits order for homog case
22 
23
24  pCopyAddFast0(b, a1, monom);  // now a2 != NULL -- set up b
25
26  // MAIN LOOP:
27  Top:     // compare b = monom*a1 and a2 w.r.t. monomial ordering
28    register long d;
29    d = pGetComp(a2) - pGetComp(b);
30    NonZeroTestA(d, pComponentOrder, goto NotEqual);
31    d = pGetOrder(b) - pGetOrder(a2);
32    NonZeroTestA(d, pOrdSgn, goto NotEqual);
33    _pMonComp_otEXP_nwEVEN(b, a2, pVariables1W, d, NonZeroA(d, pLexSgn, goto NotEqual ), goto Equal);;
34
35  Equal:   // b equals a2
36    assume(pComp0(b, a2) == 0);
37    tb = npMultM(pGetCoeff(a1), tm);
38    tc = pGetCoeff(a2);
39    if (!npEqualM(tc, tb))
40    {
41      tc=npSubM(tc, tb);
42      ;
43      pSetCoeff0(a2,tc); // adjust coeff of a2
44      a = pNext(a) = a2; // append a2 to result and advance a2
45      pIter(a2);
46    }
47    else
48    { // coeffs are equal, so their difference is 0:
49      c = a2;  // do not append anything to result: Delete a2 and advance
50      pIter(a2);
51      ;
52      pFree1(c);
53    }
54    ;
55    pIter(a1);
56    if (a2 == NULL || a1 == NULL) goto Finish; // are we done ?
57    pCopyAddFast0(b, a1, monom); // No! So, get new b = a1*monom
58    goto Top;
59
60  NotEqual:     // b != a2
61    if (d < 0)  // b < a2:
62    {
63      assume(pComp0(b, a2) == -1);
64      a = pNext(a) = a2;// append a2 to result and advance a2
65      pIter(a2);
66      if (a2==NULL) goto Finish;;
67      goto Top;
68    }
69    else // now d >= 0, i.e., b > a2
70    {
71      assume(pComp0(b, a2) == 1);
72      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
73      a = pNext(a) = b;       // append b to result and advance a1
74      pIter(a1);
75      if (a1 == NULL)         // are we done?
76      {
77        b = pNew();
78        goto Finish;
79      }
80      b = pNew();
81      pCopyAddFast0(b, a1, monom); // No! So, update b = a1*monom
82      goto Top;
83    }
84 
85 Finish: // a1 or a2 is NULL: Clean-up time
86   assume(a1 == NULL || a2 == NULL);
87   if (a1 == NULL) // append rest of a2 to result
88     pNext(a) = a2;
89   else  // append (- a1*monom) to result
90     spMultCopyX(a1, monom, a, tneg, spNoether);
91   ;
92   if (b != NULL) pFree1(b);
93}
94static void spSpolyLoop_chMODP_otCOMPEXP_homGEN_nwODD
95(poly a1, poly a2, poly monom, poly spNoether)
96{
97  poly a = monom,                         // collects the result
98       b = NULL,                          // stores a1*monom
99       c;                                 // used for temporary storage
100  number tm   = pGetCoeff(monom),         // coefficient of monom
101         tneg = npNegM(tm),        // - (coefficient of monom)
102         tb,                              // used for tm*coeff(a1)
103         tc;                              // used for intermediate coeff
104
105  Order_t order;                          // used for homog case
106
107  if (a2==NULL) goto Finish;              // we are done if a2 is 0
108  b = pNew();   
109
110  ;              // inits order for homog case
111 
112
113  pCopyAddFast0(b, a1, monom);  // now a2 != NULL -- set up b
114
115  // MAIN LOOP:
116  Top:     // compare b = monom*a1 and a2 w.r.t. monomial ordering
117    register long d;
118    d = pGetComp(a2) - pGetComp(b);
119    NonZeroTestA(d, pComponentOrder, goto NotEqual);
120    d = pGetOrder(b) - pGetOrder(a2);
121    NonZeroTestA(d, pOrdSgn, goto NotEqual);
122    _pMonComp_otEXP_nwODD(b, a2, pVariables1W, d, NonZeroA(d, pLexSgn, goto NotEqual ), goto Equal);;
123
124  Equal:   // b equals a2
125    assume(pComp0(b, a2) == 0);
126    tb = npMultM(pGetCoeff(a1), tm);
127    tc = pGetCoeff(a2);
128    if (!npEqualM(tc, tb))
129    {
130      tc=npSubM(tc, tb);
131      ;
132      pSetCoeff0(a2,tc); // adjust coeff of a2
133      a = pNext(a) = a2; // append a2 to result and advance a2
134      pIter(a2);
135    }
136    else
137    { // coeffs are equal, so their difference is 0:
138      c = a2;  // do not append anything to result: Delete a2 and advance
139      pIter(a2);
140      ;
141      pFree1(c);
142    }
143    ;
144    pIter(a1);
145    if (a2 == NULL || a1 == NULL) goto Finish; // are we done ?
146    pCopyAddFast0(b, a1, monom); // No! So, get new b = a1*monom
147    goto Top;
148
149  NotEqual:     // b != a2
150    if (d < 0)  // b < a2:
151    {
152      assume(pComp0(b, a2) == -1);
153      a = pNext(a) = a2;// append a2 to result and advance a2
154      pIter(a2);
155      if (a2==NULL) goto Finish;;
156      goto Top;
157    }
158    else // now d >= 0, i.e., b > a2
159    {
160      assume(pComp0(b, a2) == 1);
161      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
162      a = pNext(a) = b;       // append b to result and advance a1
163      pIter(a1);
164      if (a1 == NULL)         // are we done?
165      {
166        b = pNew();
167        goto Finish;
168      }
169      b = pNew();
170      pCopyAddFast0(b, a1, monom); // No! So, update b = a1*monom
171      goto Top;
172    }
173 
174 Finish: // a1 or a2 is NULL: Clean-up time
175   assume(a1 == NULL || a2 == NULL);
176   if (a1 == NULL) // append rest of a2 to result
177     pNext(a) = a2;
178   else  // append (- a1*monom) to result
179     spMultCopyX(a1, monom, a, tneg, spNoether);
180   ;
181   if (b != NULL) pFree1(b);
182}
183static void spSpolyLoop_chMODP_otCOMPEXP_homGEN_nwONE
184(poly a1, poly a2, poly monom, poly spNoether)
185{
186  poly a = monom,                         // collects the result
187       b = NULL,                          // stores a1*monom
188       c;                                 // used for temporary storage
189  number tm   = pGetCoeff(monom),         // coefficient of monom
190         tneg = npNegM(tm),        // - (coefficient of monom)
191         tb,                              // used for tm*coeff(a1)
192         tc;                              // used for intermediate coeff
193
194  Order_t order;                          // used for homog case
195
196  if (a2==NULL) goto Finish;              // we are done if a2 is 0
197  b = pNew();   
198
199  ;              // inits order for homog case
200 
201
202  pCopyAddFast0(b, a1, monom);  // now a2 != NULL -- set up b
203
204  // MAIN LOOP:
205  Top:     // compare b = monom*a1 and a2 w.r.t. monomial ordering
206    register long d;
207    d = pGetComp(a2) - pGetComp(b);
208    NonZeroTestA(d, pComponentOrder, goto NotEqual);
209    d = pGetOrder(b) - pGetOrder(a2);
210    NonZeroTestA(d, pOrdSgn, goto NotEqual);
211    _pMonComp_otEXP_nwONE(b, a2, d, NonZeroA(d, pLexSgn, goto NotEqual ), goto Equal);;
212
213  Equal:   // b equals a2
214    assume(pComp0(b, a2) == 0);
215    tb = npMultM(pGetCoeff(a1), tm);
216    tc = pGetCoeff(a2);
217    if (!npEqualM(tc, tb))
218    {
219      tc=npSubM(tc, tb);
220      ;
221      pSetCoeff0(a2,tc); // adjust coeff of a2
222      a = pNext(a) = a2; // append a2 to result and advance a2
223      pIter(a2);
224    }
225    else
226    { // coeffs are equal, so their difference is 0:
227      c = a2;  // do not append anything to result: Delete a2 and advance
228      pIter(a2);
229      ;
230      pFree1(c);
231    }
232    ;
233    pIter(a1);
234    if (a2 == NULL || a1 == NULL) goto Finish; // are we done ?
235    pCopyAddFast0(b, a1, monom); // No! So, get new b = a1*monom
236    goto Top;
237
238  NotEqual:     // b != a2
239    if (d < 0)  // b < a2:
240    {
241      assume(pComp0(b, a2) == -1);
242      a = pNext(a) = a2;// append a2 to result and advance a2
243      pIter(a2);
244      if (a2==NULL) goto Finish;;
245      goto Top;
246    }
247    else // now d >= 0, i.e., b > a2
248    {
249      assume(pComp0(b, a2) == 1);
250      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
251      a = pNext(a) = b;       // append b to result and advance a1
252      pIter(a1);
253      if (a1 == NULL)         // are we done?
254      {
255        b = pNew();
256        goto Finish;
257      }
258      b = pNew();
259      pCopyAddFast0(b, a1, monom); // No! So, update b = a1*monom
260      goto Top;
261    }
262 
263 Finish: // a1 or a2 is NULL: Clean-up time
264   assume(a1 == NULL || a2 == NULL);
265   if (a1 == NULL) // append rest of a2 to result
266     pNext(a) = a2;
267   else  // append (- a1*monom) to result
268     spMultCopyX(a1, monom, a, tneg, spNoether);
269   ;
270   if (b != NULL) pFree1(b);
271}
272static void spSpolyLoop_chMODP_otCOMPEXP_homGEN_nwTWO
273(poly a1, poly a2, poly monom, poly spNoether)
274{
275  poly a = monom,                         // collects the result
276       b = NULL,                          // stores a1*monom
277       c;                                 // used for temporary storage
278  number tm   = pGetCoeff(monom),         // coefficient of monom
279         tneg = npNegM(tm),        // - (coefficient of monom)
280         tb,                              // used for tm*coeff(a1)
281         tc;                              // used for intermediate coeff
282
283  Order_t order;                          // used for homog case
284
285  if (a2==NULL) goto Finish;              // we are done if a2 is 0
286  b = pNew();   
287
288  ;              // inits order for homog case
289 
290
291  pCopyAddFast0(b, a1, monom);  // now a2 != NULL -- set up b
292
293  // MAIN LOOP:
294  Top:     // compare b = monom*a1 and a2 w.r.t. monomial ordering
295    register long d;
296    d = pGetComp(a2) - pGetComp(b);
297    NonZeroTestA(d, pComponentOrder, goto NotEqual);
298    d = pGetOrder(b) - pGetOrder(a2);
299    NonZeroTestA(d, pOrdSgn, goto NotEqual);
300    _pMonComp_otEXP_nwTWO(b, a2, d, NonZeroA(d, pLexSgn, goto NotEqual ), goto Equal);;
301
302  Equal:   // b equals a2
303    assume(pComp0(b, a2) == 0);
304    tb = npMultM(pGetCoeff(a1), tm);
305    tc = pGetCoeff(a2);
306    if (!npEqualM(tc, tb))
307    {
308      tc=npSubM(tc, tb);
309      ;
310      pSetCoeff0(a2,tc); // adjust coeff of a2
311      a = pNext(a) = a2; // append a2 to result and advance a2
312      pIter(a2);
313    }
314    else
315    { // coeffs are equal, so their difference is 0:
316      c = a2;  // do not append anything to result: Delete a2 and advance
317      pIter(a2);
318      ;
319      pFree1(c);
320    }
321    ;
322    pIter(a1);
323    if (a2 == NULL || a1 == NULL) goto Finish; // are we done ?
324    pCopyAddFast0(b, a1, monom); // No! So, get new b = a1*monom
325    goto Top;
326
327  NotEqual:     // b != a2
328    if (d < 0)  // b < a2:
329    {
330      assume(pComp0(b, a2) == -1);
331      a = pNext(a) = a2;// append a2 to result and advance a2
332      pIter(a2);
333      if (a2==NULL) goto Finish;;
334      goto Top;
335    }
336    else // now d >= 0, i.e., b > a2
337    {
338      assume(pComp0(b, a2) == 1);
339      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
340      a = pNext(a) = b;       // append b to result and advance a1
341      pIter(a1);
342      if (a1 == NULL)         // are we done?
343      {
344        b = pNew();
345        goto Finish;
346      }
347      b = pNew();
348      pCopyAddFast0(b, a1, monom); // No! So, update b = a1*monom
349      goto Top;
350    }
351 
352 Finish: // a1 or a2 is NULL: Clean-up time
353   assume(a1 == NULL || a2 == NULL);
354   if (a1 == NULL) // append rest of a2 to result
355     pNext(a) = a2;
356   else  // append (- a1*monom) to result
357     spMultCopyX(a1, monom, a, tneg, spNoether);
358   ;
359   if (b != NULL) pFree1(b);
360}
361static void spSpolyLoop_chMODP_otCOMPEXP_homYES_nwEVEN
362(poly a1, poly a2, poly monom, poly spNoether)
363{
364  poly a = monom,                         // collects the result
365       b = NULL,                          // stores a1*monom
366       c;                                 // used for temporary storage
367  number tm   = pGetCoeff(monom),         // coefficient of monom
368         tneg = npNegM(tm),        // - (coefficient of monom)
369         tb,                              // used for tm*coeff(a1)
370         tc;                              // used for intermediate coeff
371
372  Order_t order;                          // used for homog case
373
374  if (a2==NULL) goto Finish;              // we are done if a2 is 0
375  b = pNew();   
376
377  order = pGetOrder(a2);              // inits order for homog case
378 
379
380  pCopyAddFastHomog(b, a1, monom, order);  // now a2 != NULL -- set up b
381
382  // MAIN LOOP:
383  Top:     // compare b = monom*a1 and a2 w.r.t. monomial ordering
384    register long d;
385    d = pGetComp(a2) - pGetComp(b);
386    NonZeroTestA(d, pComponentOrder, goto NotEqual);
387    _pMonComp_otEXP_nwEVEN(b, a2, pVariables1W, d, NonZeroA(d, pLexSgn, goto NotEqual ), goto Equal);;
388
389  Equal:   // b equals a2
390    assume(pComp0(b, a2) == 0);
391    tb = npMultM(pGetCoeff(a1), tm);
392    tc = pGetCoeff(a2);
393    if (!npEqualM(tc, tb))
394    {
395      tc=npSubM(tc, tb);
396      ;
397      pSetCoeff0(a2,tc); // adjust coeff of a2
398      a = pNext(a) = a2; // append a2 to result and advance a2
399      pIter(a2);
400    }
401    else
402    { // coeffs are equal, so their difference is 0:
403      c = a2;  // do not append anything to result: Delete a2 and advance
404      pIter(a2);
405      ;
406      pFree1(c);
407    }
408    ;
409    pIter(a1);
410    if (a2 == NULL || a1 == NULL) goto Finish; // are we done ?
411    pCopyAddFastHomog(b, a1, monom, order); // No! So, get new b = a1*monom
412    goto Top;
413
414  NotEqual:     // b != a2
415    if (d < 0)  // b < a2:
416    {
417      assume(pComp0(b, a2) == -1);
418      a = pNext(a) = a2;// append a2 to result and advance a2
419      pIter(a2);
420      if (a2==NULL) goto Finish;;
421      goto Top;
422    }
423    else // now d >= 0, i.e., b > a2
424    {
425      assume(pComp0(b, a2) == 1);
426      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
427      a = pNext(a) = b;       // append b to result and advance a1
428      pIter(a1);
429      if (a1 == NULL)         // are we done?
430      {
431        b = pNew();
432        goto Finish;
433      }
434      b = pNew();
435      pCopyAddFastHomog(b, a1, monom, order); // No! So, update b = a1*monom
436      goto Top;
437    }
438 
439 Finish: // a1 or a2 is NULL: Clean-up time
440   assume(a1 == NULL || a2 == NULL);
441   if (a1 == NULL) // append rest of a2 to result
442     pNext(a) = a2;
443   else  // append (- a1*monom) to result
444     spMultCopyX(a1, monom, a, tneg, spNoether);
445   ;
446   if (b != NULL) pFree1(b);
447}
448static void spSpolyLoop_chMODP_otCOMPEXP_homYES_nwODD
449(poly a1, poly a2, poly monom, poly spNoether)
450{
451  poly a = monom,                         // collects the result
452       b = NULL,                          // stores a1*monom
453       c;                                 // used for temporary storage
454  number tm   = pGetCoeff(monom),         // coefficient of monom
455         tneg = npNegM(tm),        // - (coefficient of monom)
456         tb,                              // used for tm*coeff(a1)
457         tc;                              // used for intermediate coeff
458
459  Order_t order;                          // used for homog case
460
461  if (a2==NULL) goto Finish;              // we are done if a2 is 0
462  b = pNew();   
463
464  order = pGetOrder(a2);              // inits order for homog case
465 
466
467  pCopyAddFastHomog(b, a1, monom, order);  // now a2 != NULL -- set up b
468
469  // MAIN LOOP:
470  Top:     // compare b = monom*a1 and a2 w.r.t. monomial ordering
471    register long d;
472    d = pGetComp(a2) - pGetComp(b);
473    NonZeroTestA(d, pComponentOrder, goto NotEqual);
474    _pMonComp_otEXP_nwODD(b, a2, pVariables1W, d, NonZeroA(d, pLexSgn, goto NotEqual ), goto Equal);;
475
476  Equal:   // b equals a2
477    assume(pComp0(b, a2) == 0);
478    tb = npMultM(pGetCoeff(a1), tm);
479    tc = pGetCoeff(a2);
480    if (!npEqualM(tc, tb))
481    {
482      tc=npSubM(tc, tb);
483      ;
484      pSetCoeff0(a2,tc); // adjust coeff of a2
485      a = pNext(a) = a2; // append a2 to result and advance a2
486      pIter(a2);
487    }
488    else
489    { // coeffs are equal, so their difference is 0:
490      c = a2;  // do not append anything to result: Delete a2 and advance
491      pIter(a2);
492      ;
493      pFree1(c);
494    }
495    ;
496    pIter(a1);
497    if (a2 == NULL || a1 == NULL) goto Finish; // are we done ?
498    pCopyAddFastHomog(b, a1, monom, order); // No! So, get new b = a1*monom
499    goto Top;
500
501  NotEqual:     // b != a2
502    if (d < 0)  // b < a2:
503    {
504      assume(pComp0(b, a2) == -1);
505      a = pNext(a) = a2;// append a2 to result and advance a2
506      pIter(a2);
507      if (a2==NULL) goto Finish;;
508      goto Top;
509    }
510    else // now d >= 0, i.e., b > a2
511    {
512      assume(pComp0(b, a2) == 1);
513      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
514      a = pNext(a) = b;       // append b to result and advance a1
515      pIter(a1);
516      if (a1 == NULL)         // are we done?
517      {
518        b = pNew();
519        goto Finish;
520      }
521      b = pNew();
522      pCopyAddFastHomog(b, a1, monom, order); // No! So, update b = a1*monom
523      goto Top;
524    }
525 
526 Finish: // a1 or a2 is NULL: Clean-up time
527   assume(a1 == NULL || a2 == NULL);
528   if (a1 == NULL) // append rest of a2 to result
529     pNext(a) = a2;
530   else  // append (- a1*monom) to result
531     spMultCopyX(a1, monom, a, tneg, spNoether);
532   ;
533   if (b != NULL) pFree1(b);
534}
535static void spSpolyLoop_chMODP_otCOMPEXP_homYES_nwONE
536(poly a1, poly a2, poly monom, poly spNoether)
537{
538  poly a = monom,                         // collects the result
539       b = NULL,                          // stores a1*monom
540       c;                                 // used for temporary storage
541  number tm   = pGetCoeff(monom),         // coefficient of monom
542         tneg = npNegM(tm),        // - (coefficient of monom)
543         tb,                              // used for tm*coeff(a1)
544         tc;                              // used for intermediate coeff
545
546  Order_t order;                          // used for homog case
547
548  if (a2==NULL) goto Finish;              // we are done if a2 is 0
549  b = pNew();   
550
551  order = pGetOrder(a2);              // inits order for homog case
552 
553
554  pCopyAddFastHomog(b, a1, monom, order);  // now a2 != NULL -- set up b
555
556  // MAIN LOOP:
557  Top:     // compare b = monom*a1 and a2 w.r.t. monomial ordering
558    register long d;
559    d = pGetComp(a2) - pGetComp(b);
560    NonZeroTestA(d, pComponentOrder, goto NotEqual);
561    _pMonComp_otEXP_nwONE(b, a2, d, NonZeroA(d, pLexSgn, goto NotEqual ), goto Equal);;
562
563  Equal:   // b equals a2
564    assume(pComp0(b, a2) == 0);
565    tb = npMultM(pGetCoeff(a1), tm);
566    tc = pGetCoeff(a2);
567    if (!npEqualM(tc, tb))
568    {
569      tc=npSubM(tc, tb);
570      ;
571      pSetCoeff0(a2,tc); // adjust coeff of a2
572      a = pNext(a) = a2; // append a2 to result and advance a2
573      pIter(a2);
574    }
575    else
576    { // coeffs are equal, so their difference is 0:
577      c = a2;  // do not append anything to result: Delete a2 and advance
578      pIter(a2);
579      ;
580      pFree1(c);
581    }
582    ;
583    pIter(a1);
584    if (a2 == NULL || a1 == NULL) goto Finish; // are we done ?
585    pCopyAddFastHomog(b, a1, monom, order); // No! So, get new b = a1*monom
586    goto Top;
587
588  NotEqual:     // b != a2
589    if (d < 0)  // b < a2:
590    {
591      assume(pComp0(b, a2) == -1);
592      a = pNext(a) = a2;// append a2 to result and advance a2
593      pIter(a2);
594      if (a2==NULL) goto Finish;;
595      goto Top;
596    }
597    else // now d >= 0, i.e., b > a2
598    {
599      assume(pComp0(b, a2) == 1);
600      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
601      a = pNext(a) = b;       // append b to result and advance a1
602      pIter(a1);
603      if (a1 == NULL)         // are we done?
604      {
605        b = pNew();
606        goto Finish;
607      }
608      b = pNew();
609      pCopyAddFastHomog(b, a1, monom, order); // No! So, update b = a1*monom
610      goto Top;
611    }
612 
613 Finish: // a1 or a2 is NULL: Clean-up time
614   assume(a1 == NULL || a2 == NULL);
615   if (a1 == NULL) // append rest of a2 to result
616     pNext(a) = a2;
617   else  // append (- a1*monom) to result
618     spMultCopyX(a1, monom, a, tneg, spNoether);
619   ;
620   if (b != NULL) pFree1(b);
621}
622static void spSpolyLoop_chMODP_otCOMPEXP_homYES_nwTWO
623(poly a1, poly a2, poly monom, poly spNoether)
624{
625  poly a = monom,                         // collects the result
626       b = NULL,                          // stores a1*monom
627       c;                                 // used for temporary storage
628  number tm   = pGetCoeff(monom),         // coefficient of monom
629         tneg = npNegM(tm),        // - (coefficient of monom)
630         tb,                              // used for tm*coeff(a1)
631         tc;                              // used for intermediate coeff
632
633  Order_t order;                          // used for homog case
634
635  if (a2==NULL) goto Finish;              // we are done if a2 is 0
636  b = pNew();   
637
638  order = pGetOrder(a2);              // inits order for homog case
639 
640
641  pCopyAddFastHomog(b, a1, monom, order);  // now a2 != NULL -- set up b
642
643  // MAIN LOOP:
644  Top:     // compare b = monom*a1 and a2 w.r.t. monomial ordering
645    register long d;
646    d = pGetComp(a2) - pGetComp(b);
647    NonZeroTestA(d, pComponentOrder, goto NotEqual);
648    _pMonComp_otEXP_nwTWO(b, a2, d, NonZeroA(d, pLexSgn, goto NotEqual ), goto Equal);;
649
650  Equal:   // b equals a2
651    assume(pComp0(b, a2) == 0);
652    tb = npMultM(pGetCoeff(a1), tm);
653    tc = pGetCoeff(a2);
654    if (!npEqualM(tc, tb))
655    {
656      tc=npSubM(tc, tb);
657      ;
658      pSetCoeff0(a2,tc); // adjust coeff of a2
659      a = pNext(a) = a2; // append a2 to result and advance a2
660      pIter(a2);
661    }
662    else
663    { // coeffs are equal, so their difference is 0:
664      c = a2;  // do not append anything to result: Delete a2 and advance
665      pIter(a2);
666      ;
667      pFree1(c);
668    }
669    ;
670    pIter(a1);
671    if (a2 == NULL || a1 == NULL) goto Finish; // are we done ?
672    pCopyAddFastHomog(b, a1, monom, order); // No! So, get new b = a1*monom
673    goto Top;
674
675  NotEqual:     // b != a2
676    if (d < 0)  // b < a2:
677    {
678      assume(pComp0(b, a2) == -1);
679      a = pNext(a) = a2;// append a2 to result and advance a2
680      pIter(a2);
681      if (a2==NULL) goto Finish;;
682      goto Top;
683    }
684    else // now d >= 0, i.e., b > a2
685    {
686      assume(pComp0(b, a2) == 1);
687      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
688      a = pNext(a) = b;       // append b to result and advance a1
689      pIter(a1);
690      if (a1 == NULL)         // are we done?
691      {
692        b = pNew();
693        goto Finish;
694      }
695      b = pNew();
696      pCopyAddFastHomog(b, a1, monom, order); // No! So, update b = a1*monom
697      goto Top;
698    }
699 
700 Finish: // a1 or a2 is NULL: Clean-up time
701   assume(a1 == NULL || a2 == NULL);
702   if (a1 == NULL) // append rest of a2 to result
703     pNext(a) = a2;
704   else  // append (- a1*monom) to result
705     spMultCopyX(a1, monom, a, tneg, spNoether);
706   ;
707   if (b != NULL) pFree1(b);
708}
709static void spSpolyLoop_chMODP_otEXPCOMP_homGEN_nwEVEN
710(poly a1, poly a2, poly monom, poly spNoether)
711{
712  poly a = monom,                         // collects the result
713       b = NULL,                          // stores a1*monom
714       c;                                 // used for temporary storage
715  number tm   = pGetCoeff(monom),         // coefficient of monom
716         tneg = npNegM(tm),        // - (coefficient of monom)
717         tb,                              // used for tm*coeff(a1)
718         tc;                              // used for intermediate coeff
719
720  Order_t order;                          // used for homog case
721
722  if (a2==NULL) goto Finish;              // we are done if a2 is 0
723  b = pNew();   
724
725  ;              // inits order for homog case
726 
727
728  pCopyAddFast0(b, a1, monom);  // now a2 != NULL -- set up b
729
730  // MAIN LOOP:
731  Top:     // compare b = monom*a1 and a2 w.r.t. monomial ordering
732    register long d;
733    d = pGetOrder(b) - pGetOrder(a2);
734    NonZeroTestA(d, pOrdSgn, goto NotEqual);
735    _pMonComp_otEXPCOMP_nwEVEN(b, a2, pVariables1W, d, NonZeroA(d, pLexSgn, goto NotEqual ), goto Equal);;
736
737  Equal:   // b equals a2
738    assume(pComp0(b, a2) == 0);
739    tb = npMultM(pGetCoeff(a1), tm);
740    tc = pGetCoeff(a2);
741    if (!npEqualM(tc, tb))
742    {
743      tc=npSubM(tc, tb);
744      ;
745      pSetCoeff0(a2,tc); // adjust coeff of a2
746      a = pNext(a) = a2; // append a2 to result and advance a2
747      pIter(a2);
748    }
749    else
750    { // coeffs are equal, so their difference is 0:
751      c = a2;  // do not append anything to result: Delete a2 and advance
752      pIter(a2);
753      ;
754      pFree1(c);
755    }
756    ;
757    pIter(a1);
758    if (a2 == NULL || a1 == NULL) goto Finish; // are we done ?
759    pCopyAddFast0(b, a1, monom); // No! So, get new b = a1*monom
760    goto Top;
761
762  NotEqual:     // b != a2
763    if (d < 0)  // b < a2:
764    {
765      assume(pComp0(b, a2) == -1);
766      a = pNext(a) = a2;// append a2 to result and advance a2
767      pIter(a2);
768      if (a2==NULL) goto Finish;;
769      goto Top;
770    }
771    else // now d >= 0, i.e., b > a2
772    {
773      assume(pComp0(b, a2) == 1);
774      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
775      a = pNext(a) = b;       // append b to result and advance a1
776      pIter(a1);
777      if (a1 == NULL)         // are we done?
778      {
779        b = pNew();
780        goto Finish;
781      }
782      b = pNew();
783      pCopyAddFast0(b, a1, monom); // No! So, update b = a1*monom
784      goto Top;
785    }
786 
787 Finish: // a1 or a2 is NULL: Clean-up time
788   assume(a1 == NULL || a2 == NULL);
789   if (a1 == NULL) // append rest of a2 to result
790     pNext(a) = a2;
791   else  // append (- a1*monom) to result
792     spMultCopyX(a1, monom, a, tneg, spNoether);
793   ;
794   if (b != NULL) pFree1(b);
795}
796static void spSpolyLoop_chMODP_otEXPCOMP_homGEN_nwODD
797(poly a1, poly a2, poly monom, poly spNoether)
798{
799  poly a = monom,                         // collects the result
800       b = NULL,                          // stores a1*monom
801       c;                                 // used for temporary storage
802  number tm   = pGetCoeff(monom),         // coefficient of monom
803         tneg = npNegM(tm),        // - (coefficient of monom)
804         tb,                              // used for tm*coeff(a1)
805         tc;                              // used for intermediate coeff
806
807  Order_t order;                          // used for homog case
808
809  if (a2==NULL) goto Finish;              // we are done if a2 is 0
810  b = pNew();   
811
812  ;              // inits order for homog case
813 
814
815  pCopyAddFast0(b, a1, monom);  // now a2 != NULL -- set up b
816
817  // MAIN LOOP:
818  Top:     // compare b = monom*a1 and a2 w.r.t. monomial ordering
819    register long d;
820    d = pGetOrder(b) - pGetOrder(a2);
821    NonZeroTestA(d, pOrdSgn, goto NotEqual);
822    _pMonComp_otEXPCOMP_nwODD(b, a2, pVariables1W, d, NonZeroA(d, pLexSgn, goto NotEqual ), goto Equal);;
823
824  Equal:   // b equals a2
825    assume(pComp0(b, a2) == 0);
826    tb = npMultM(pGetCoeff(a1), tm);
827    tc = pGetCoeff(a2);
828    if (!npEqualM(tc, tb))
829    {
830      tc=npSubM(tc, tb);
831      ;
832      pSetCoeff0(a2,tc); // adjust coeff of a2
833      a = pNext(a) = a2; // append a2 to result and advance a2
834      pIter(a2);
835    }
836    else
837    { // coeffs are equal, so their difference is 0:
838      c = a2;  // do not append anything to result: Delete a2 and advance
839      pIter(a2);
840      ;
841      pFree1(c);
842    }
843    ;
844    pIter(a1);
845    if (a2 == NULL || a1 == NULL) goto Finish; // are we done ?
846    pCopyAddFast0(b, a1, monom); // No! So, get new b = a1*monom
847    goto Top;
848
849  NotEqual:     // b != a2
850    if (d < 0)  // b < a2:
851    {
852      assume(pComp0(b, a2) == -1);
853      a = pNext(a) = a2;// append a2 to result and advance a2
854      pIter(a2);
855      if (a2==NULL) goto Finish;;
856      goto Top;
857    }
858    else // now d >= 0, i.e., b > a2
859    {
860      assume(pComp0(b, a2) == 1);
861      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
862      a = pNext(a) = b;       // append b to result and advance a1
863      pIter(a1);
864      if (a1 == NULL)         // are we done?
865      {
866        b = pNew();
867        goto Finish;
868      }
869      b = pNew();
870      pCopyAddFast0(b, a1, monom); // No! So, update b = a1*monom
871      goto Top;
872    }
873 
874 Finish: // a1 or a2 is NULL: Clean-up time
875   assume(a1 == NULL || a2 == NULL);
876   if (a1 == NULL) // append rest of a2 to result
877     pNext(a) = a2;
878   else  // append (- a1*monom) to result
879     spMultCopyX(a1, monom, a, tneg, spNoether);
880   ;
881   if (b != NULL) pFree1(b);
882}
883static void spSpolyLoop_chMODP_otEXPCOMP_homGEN_nwONE
884(poly a1, poly a2, poly monom, poly spNoether)
885{
886  poly a = monom,                         // collects the result
887       b = NULL,                          // stores a1*monom
888       c;                                 // used for temporary storage
889  number tm   = pGetCoeff(monom),         // coefficient of monom
890         tneg = npNegM(tm),        // - (coefficient of monom)
891         tb,                              // used for tm*coeff(a1)
892         tc;                              // used for intermediate coeff
893
894  Order_t order;                          // used for homog case
895
896  if (a2==NULL) goto Finish;              // we are done if a2 is 0
897  b = pNew();   
898
899  ;              // inits order for homog case
900 
901
902  pCopyAddFast0(b, a1, monom);  // now a2 != NULL -- set up b
903
904  // MAIN LOOP:
905  Top:     // compare b = monom*a1 and a2 w.r.t. monomial ordering
906    register long d;
907    d = pGetOrder(b) - pGetOrder(a2);
908    NonZeroTestA(d, pOrdSgn, goto NotEqual);
909    _pMonComp_otEXPCOMP_nwONE(b, a2, d, NonZeroA(d, pLexSgn, goto NotEqual ), goto Equal);;
910
911  Equal:   // b equals a2
912    assume(pComp0(b, a2) == 0);
913    tb = npMultM(pGetCoeff(a1), tm);
914    tc = pGetCoeff(a2);
915    if (!npEqualM(tc, tb))
916    {
917      tc=npSubM(tc, tb);
918      ;
919      pSetCoeff0(a2,tc); // adjust coeff of a2
920      a = pNext(a) = a2; // append a2 to result and advance a2
921      pIter(a2);
922    }
923    else
924    { // coeffs are equal, so their difference is 0:
925      c = a2;  // do not append anything to result: Delete a2 and advance
926      pIter(a2);
927      ;
928      pFree1(c);
929    }
930    ;
931    pIter(a1);
932    if (a2 == NULL || a1 == NULL) goto Finish; // are we done ?
933    pCopyAddFast0(b, a1, monom); // No! So, get new b = a1*monom
934    goto Top;
935
936  NotEqual:     // b != a2
937    if (d < 0)  // b < a2:
938    {
939      assume(pComp0(b, a2) == -1);
940      a = pNext(a) = a2;// append a2 to result and advance a2
941      pIter(a2);
942      if (a2==NULL) goto Finish;;
943      goto Top;
944    }
945    else // now d >= 0, i.e., b > a2
946    {
947      assume(pComp0(b, a2) == 1);
948      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
949      a = pNext(a) = b;       // append b to result and advance a1
950      pIter(a1);
951      if (a1 == NULL)         // are we done?
952      {
953        b = pNew();
954        goto Finish;
955      }
956      b = pNew();
957      pCopyAddFast0(b, a1, monom); // No! So, update b = a1*monom
958      goto Top;
959    }
960 
961 Finish: // a1 or a2 is NULL: Clean-up time
962   assume(a1 == NULL || a2 == NULL);
963   if (a1 == NULL) // append rest of a2 to result
964     pNext(a) = a2;
965   else  // append (- a1*monom) to result
966     spMultCopyX(a1, monom, a, tneg, spNoether);
967   ;
968   if (b != NULL) pFree1(b);
969}
970static void spSpolyLoop_chMODP_otEXPCOMP_homGEN_nwTWO
971(poly a1, poly a2, poly monom, poly spNoether)
972{
973  poly a = monom,                         // collects the result
974       b = NULL,                          // stores a1*monom
975       c;                                 // used for temporary storage
976  number tm   = pGetCoeff(monom),         // coefficient of monom
977         tneg = npNegM(tm),        // - (coefficient of monom)
978         tb,                              // used for tm*coeff(a1)
979         tc;                              // used for intermediate coeff
980
981  Order_t order;                          // used for homog case
982
983  if (a2==NULL) goto Finish;              // we are done if a2 is 0
984  b = pNew();   
985
986  ;              // inits order for homog case
987 
988
989  pCopyAddFast0(b, a1, monom);  // now a2 != NULL -- set up b
990
991  // MAIN LOOP:
992  Top:     // compare b = monom*a1 and a2 w.r.t. monomial ordering
993    register long d;
994    d = pGetOrder(b) - pGetOrder(a2);
995    NonZeroTestA(d, pOrdSgn, goto NotEqual);
996    _pMonComp_otEXPCOMP_nwTWO(b, a2, d, NonZeroA(d, pLexSgn, goto NotEqual ), goto Equal);;
997
998  Equal:   // b equals a2
999    assume(pComp0(b, a2) == 0);
1000    tb = npMultM(pGetCoeff(a1), tm);
1001    tc = pGetCoeff(a2);
1002    if (!npEqualM(tc, tb))
1003    {
1004      tc=npSubM(tc, tb);
1005      ;
1006      pSetCoeff0(a2,tc); // adjust coeff of a2
1007      a = pNext(a) = a2; // append a2 to result and advance a2
1008      pIter(a2);
1009    }
1010    else
1011    { // coeffs are equal, so their difference is 0:
1012      c = a2;  // do not append anything to result: Delete a2 and advance
1013      pIter(a2);
1014      ;
1015      pFree1(c);
1016    }
1017    ;
1018    pIter(a1);
1019    if (a2 == NULL || a1 == NULL) goto Finish; // are we done ?
1020    pCopyAddFast0(b, a1, monom); // No! So, get new b = a1*monom
1021    goto Top;
1022
1023  NotEqual:     // b != a2
1024    if (d < 0)  // b < a2:
1025    {
1026      assume(pComp0(b, a2) == -1);
1027      a = pNext(a) = a2;// append a2 to result and advance a2
1028      pIter(a2);
1029      if (a2==NULL) goto Finish;;
1030      goto Top;
1031    }
1032    else // now d >= 0, i.e., b > a2
1033    {
1034      assume(pComp0(b, a2) == 1);
1035      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
1036      a = pNext(a) = b;       // append b to result and advance a1
1037      pIter(a1);
1038      if (a1 == NULL)         // are we done?
1039      {
1040        b = pNew();
1041        goto Finish;
1042      }
1043      b = pNew();
1044      pCopyAddFast0(b, a1, monom); // No! So, update b = a1*monom
1045      goto Top;
1046    }
1047 
1048 Finish: // a1 or a2 is NULL: Clean-up time
1049   assume(a1 == NULL || a2 == NULL);
1050   if (a1 == NULL) // append rest of a2 to result
1051     pNext(a) = a2;
1052   else  // append (- a1*monom) to result
1053     spMultCopyX(a1, monom, a, tneg, spNoether);
1054   ;
1055   if (b != NULL) pFree1(b);
1056}
1057static void spSpolyLoop_chMODP_otEXPCOMP_homYES_nwEVEN
1058(poly a1, poly a2, poly monom, poly spNoether)
1059{
1060  poly a = monom,                         // collects the result
1061       b = NULL,                          // stores a1*monom
1062       c;                                 // used for temporary storage
1063  number tm   = pGetCoeff(monom),         // coefficient of monom
1064         tneg = npNegM(tm),        // - (coefficient of monom)
1065         tb,                              // used for tm*coeff(a1)
1066         tc;                              // used for intermediate coeff
1067
1068  Order_t order;                          // used for homog case
1069
1070  if (a2==NULL) goto Finish;              // we are done if a2 is 0
1071  b = pNew();   
1072
1073  order = pGetOrder(a2);              // inits order for homog case
1074 
1075
1076  pCopyAddFastHomog(b, a1, monom, order);  // now a2 != NULL -- set up b
1077
1078  // MAIN LOOP:
1079  Top:     // compare b = monom*a1 and a2 w.r.t. monomial ordering
1080    register long d;
1081    _pMonComp_otEXPCOMP_nwEVEN(b, a2, pVariables1W, d, NonZeroA(d, pLexSgn, goto NotEqual ), goto Equal);;
1082
1083  Equal:   // b equals a2
1084    assume(pComp0(b, a2) == 0);
1085    tb = npMultM(pGetCoeff(a1), tm);
1086    tc = pGetCoeff(a2);
1087    if (!npEqualM(tc, tb))
1088    {
1089      tc=npSubM(tc, tb);
1090      ;
1091      pSetCoeff0(a2,tc); // adjust coeff of a2
1092      a = pNext(a) = a2; // append a2 to result and advance a2
1093      pIter(a2);
1094    }
1095    else
1096    { // coeffs are equal, so their difference is 0:
1097      c = a2;  // do not append anything to result: Delete a2 and advance
1098      pIter(a2);
1099      ;
1100      pFree1(c);
1101    }
1102    ;
1103    pIter(a1);
1104    if (a2 == NULL || a1 == NULL) goto Finish; // are we done ?
1105    pCopyAddFastHomog(b, a1, monom, order); // No! So, get new b = a1*monom
1106    goto Top;
1107
1108  NotEqual:     // b != a2
1109    if (d < 0)  // b < a2:
1110    {
1111      assume(pComp0(b, a2) == -1);
1112      a = pNext(a) = a2;// append a2 to result and advance a2
1113      pIter(a2);
1114      if (a2==NULL) goto Finish;;
1115      goto Top;
1116    }
1117    else // now d >= 0, i.e., b > a2
1118    {
1119      assume(pComp0(b, a2) == 1);
1120      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
1121      a = pNext(a) = b;       // append b to result and advance a1
1122      pIter(a1);
1123      if (a1 == NULL)         // are we done?
1124      {
1125        b = pNew();
1126        goto Finish;
1127      }
1128      b = pNew();
1129      pCopyAddFastHomog(b, a1, monom, order); // No! So, update b = a1*monom
1130      goto Top;
1131    }
1132 
1133 Finish: // a1 or a2 is NULL: Clean-up time
1134   assume(a1 == NULL || a2 == NULL);
1135   if (a1 == NULL) // append rest of a2 to result
1136     pNext(a) = a2;
1137   else  // append (- a1*monom) to result
1138     spMultCopyX(a1, monom, a, tneg, spNoether);
1139   ;
1140   if (b != NULL) pFree1(b);
1141}
1142static void spSpolyLoop_chMODP_otEXPCOMP_homYES_nwODD
1143(poly a1, poly a2, poly monom, poly spNoether)
1144{
1145  poly a = monom,                         // collects the result
1146       b = NULL,                          // stores a1*monom
1147       c;                                 // used for temporary storage
1148  number tm   = pGetCoeff(monom),         // coefficient of monom
1149         tneg = npNegM(tm),        // - (coefficient of monom)
1150         tb,                              // used for tm*coeff(a1)
1151         tc;                              // used for intermediate coeff
1152
1153  Order_t order;                          // used for homog case
1154
1155  if (a2==NULL) goto Finish;              // we are done if a2 is 0
1156  b = pNew();   
1157
1158  order = pGetOrder(a2);              // inits order for homog case
1159 
1160
1161  pCopyAddFastHomog(b, a1, monom, order);  // now a2 != NULL -- set up b
1162
1163  // MAIN LOOP:
1164  Top:     // compare b = monom*a1 and a2 w.r.t. monomial ordering
1165    register long d;
1166    _pMonComp_otEXPCOMP_nwODD(b, a2, pVariables1W, d, NonZeroA(d, pLexSgn, goto NotEqual ), goto Equal);;
1167
1168  Equal:   // b equals a2
1169    assume(pComp0(b, a2) == 0);
1170    tb = npMultM(pGetCoeff(a1), tm);
1171    tc = pGetCoeff(a2);
1172    if (!npEqualM(tc, tb))
1173    {
1174      tc=npSubM(tc, tb);
1175      ;
1176      pSetCoeff0(a2,tc); // adjust coeff of a2
1177      a = pNext(a) = a2; // append a2 to result and advance a2
1178      pIter(a2);
1179    }
1180    else
1181    { // coeffs are equal, so their difference is 0:
1182      c = a2;  // do not append anything to result: Delete a2 and advance
1183      pIter(a2);
1184      ;
1185      pFree1(c);
1186    }
1187    ;
1188    pIter(a1);
1189    if (a2 == NULL || a1 == NULL) goto Finish; // are we done ?
1190    pCopyAddFastHomog(b, a1, monom, order); // No! So, get new b = a1*monom
1191    goto Top;
1192
1193  NotEqual:     // b != a2
1194    if (d < 0)  // b < a2:
1195    {
1196      assume(pComp0(b, a2) == -1);
1197      a = pNext(a) = a2;// append a2 to result and advance a2
1198      pIter(a2);
1199      if (a2==NULL) goto Finish;;
1200      goto Top;
1201    }
1202    else // now d >= 0, i.e., b > a2
1203    {
1204      assume(pComp0(b, a2) == 1);
1205      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
1206      a = pNext(a) = b;       // append b to result and advance a1
1207      pIter(a1);
1208      if (a1 == NULL)         // are we done?
1209      {
1210        b = pNew();
1211        goto Finish;
1212      }
1213      b = pNew();
1214      pCopyAddFastHomog(b, a1, monom, order); // No! So, update b = a1*monom
1215      goto Top;
1216    }
1217 
1218 Finish: // a1 or a2 is NULL: Clean-up time
1219   assume(a1 == NULL || a2 == NULL);
1220   if (a1 == NULL) // append rest of a2 to result
1221     pNext(a) = a2;
1222   else  // append (- a1*monom) to result
1223     spMultCopyX(a1, monom, a, tneg, spNoether);
1224   ;
1225   if (b != NULL) pFree1(b);
1226}
1227static void spSpolyLoop_chMODP_otEXPCOMP_homYES_nwONE
1228(poly a1, poly a2, poly monom, poly spNoether)
1229{
1230  poly a = monom,                         // collects the result
1231       b = NULL,                          // stores a1*monom
1232       c;                                 // used for temporary storage
1233  number tm   = pGetCoeff(monom),         // coefficient of monom
1234         tneg = npNegM(tm),        // - (coefficient of monom)
1235         tb,                              // used for tm*coeff(a1)
1236         tc;                              // used for intermediate coeff
1237
1238  Order_t order;                          // used for homog case
1239
1240  if (a2==NULL) goto Finish;              // we are done if a2 is 0
1241  b = pNew();   
1242
1243  order = pGetOrder(a2);              // inits order for homog case
1244 
1245
1246  pCopyAddFastHomog(b, a1, monom, order);  // now a2 != NULL -- set up b
1247
1248  // MAIN LOOP:
1249  Top:     // compare b = monom*a1 and a2 w.r.t. monomial ordering
1250    register long d;
1251    _pMonComp_otEXPCOMP_nwONE(b, a2, d, NonZeroA(d, pLexSgn, goto NotEqual ), goto Equal);;
1252
1253  Equal:   // b equals a2
1254    assume(pComp0(b, a2) == 0);
1255    tb = npMultM(pGetCoeff(a1), tm);
1256    tc = pGetCoeff(a2);
1257    if (!npEqualM(tc, tb))
1258    {
1259      tc=npSubM(tc, tb);
1260      ;
1261      pSetCoeff0(a2,tc); // adjust coeff of a2
1262      a = pNext(a) = a2; // append a2 to result and advance a2
1263      pIter(a2);
1264    }
1265    else
1266    { // coeffs are equal, so their difference is 0:
1267      c = a2;  // do not append anything to result: Delete a2 and advance
1268      pIter(a2);
1269      ;
1270      pFree1(c);
1271    }
1272    ;
1273    pIter(a1);
1274    if (a2 == NULL || a1 == NULL) goto Finish; // are we done ?
1275    pCopyAddFastHomog(b, a1, monom, order); // No! So, get new b = a1*monom
1276    goto Top;
1277
1278  NotEqual:     // b != a2
1279    if (d < 0)  // b < a2:
1280    {
1281      assume(pComp0(b, a2) == -1);
1282      a = pNext(a) = a2;// append a2 to result and advance a2
1283      pIter(a2);
1284      if (a2==NULL) goto Finish;;
1285      goto Top;
1286    }
1287    else // now d >= 0, i.e., b > a2
1288    {
1289      assume(pComp0(b, a2) == 1);
1290      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
1291      a = pNext(a) = b;       // append b to result and advance a1
1292      pIter(a1);
1293      if (a1 == NULL)         // are we done?
1294      {
1295        b = pNew();
1296        goto Finish;
1297      }
1298      b = pNew();
1299      pCopyAddFastHomog(b, a1, monom, order); // No! So, update b = a1*monom
1300      goto Top;
1301    }
1302 
1303 Finish: // a1 or a2 is NULL: Clean-up time
1304   assume(a1 == NULL || a2 == NULL);
1305   if (a1 == NULL) // append rest of a2 to result
1306     pNext(a) = a2;
1307   else  // append (- a1*monom) to result
1308     spMultCopyX(a1, monom, a, tneg, spNoether);
1309   ;
1310   if (b != NULL) pFree1(b);
1311}
1312static void spSpolyLoop_chMODP_otEXPCOMP_homYES_nwTWO
1313(poly a1, poly a2, poly monom, poly spNoether)
1314{
1315  poly a = monom,                         // collects the result
1316       b = NULL,                          // stores a1*monom
1317       c;                                 // used for temporary storage
1318  number tm   = pGetCoeff(monom),         // coefficient of monom
1319         tneg = npNegM(tm),        // - (coefficient of monom)
1320         tb,                              // used for tm*coeff(a1)
1321         tc;                              // used for intermediate coeff
1322
1323  Order_t order;                          // used for homog case
1324
1325  if (a2==NULL) goto Finish;              // we are done if a2 is 0
1326  b = pNew();   
1327
1328  order = pGetOrder(a2);              // inits order for homog case
1329 
1330
1331  pCopyAddFastHomog(b, a1, monom, order);  // now a2 != NULL -- set up b
1332
1333  // MAIN LOOP:
1334  Top:     // compare b = monom*a1 and a2 w.r.t. monomial ordering
1335    register long d;
1336    _pMonComp_otEXPCOMP_nwTWO(b, a2, d, NonZeroA(d, pLexSgn, goto NotEqual ), goto Equal);;
1337
1338  Equal:   // b equals a2
1339    assume(pComp0(b, a2) == 0);
1340    tb = npMultM(pGetCoeff(a1), tm);
1341    tc = pGetCoeff(a2);
1342    if (!npEqualM(tc, tb))
1343    {
1344      tc=npSubM(tc, tb);
1345      ;
1346      pSetCoeff0(a2,tc); // adjust coeff of a2
1347      a = pNext(a) = a2; // append a2 to result and advance a2
1348      pIter(a2);
1349    }
1350    else
1351    { // coeffs are equal, so their difference is 0:
1352      c = a2;  // do not append anything to result: Delete a2 and advance
1353      pIter(a2);
1354      ;
1355      pFree1(c);
1356    }
1357    ;
1358    pIter(a1);
1359    if (a2 == NULL || a1 == NULL) goto Finish; // are we done ?
1360    pCopyAddFastHomog(b, a1, monom, order); // No! So, get new b = a1*monom
1361    goto Top;
1362
1363  NotEqual:     // b != a2
1364    if (d < 0)  // b < a2:
1365    {
1366      assume(pComp0(b, a2) == -1);
1367      a = pNext(a) = a2;// append a2 to result and advance a2
1368      pIter(a2);
1369      if (a2==NULL) goto Finish;;
1370      goto Top;
1371    }
1372    else // now d >= 0, i.e., b > a2
1373    {
1374      assume(pComp0(b, a2) == 1);
1375      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
1376      a = pNext(a) = b;       // append b to result and advance a1
1377      pIter(a1);
1378      if (a1 == NULL)         // are we done?
1379      {
1380        b = pNew();
1381        goto Finish;
1382      }
1383      b = pNew();
1384      pCopyAddFastHomog(b, a1, monom, order); // No! So, update b = a1*monom
1385      goto Top;
1386    }
1387 
1388 Finish: // a1 or a2 is NULL: Clean-up time
1389   assume(a1 == NULL || a2 == NULL);
1390   if (a1 == NULL) // append rest of a2 to result
1391     pNext(a) = a2;
1392   else  // append (- a1*monom) to result
1393     spMultCopyX(a1, monom, a, tneg, spNoether);
1394   ;
1395   if (b != NULL) pFree1(b);
1396}
1397static void spSpolyLoop_chMODP_otEXP_homGEN_nwEVEN
1398(poly a1, poly a2, poly monom, poly spNoether)
1399{
1400  poly a = monom,                         // collects the result
1401       b = NULL,                          // stores a1*monom
1402       c;                                 // used for temporary storage
1403  number tm   = pGetCoeff(monom),         // coefficient of monom
1404         tneg = npNegM(tm),        // - (coefficient of monom)
1405         tb,                              // used for tm*coeff(a1)
1406         tc;                              // used for intermediate coeff
1407
1408  Order_t order;                          // used for homog case
1409
1410  if (a2==NULL) goto Finish;              // we are done if a2 is 0
1411  b = pNew();   
1412
1413  ;              // inits order for homog case
1414 
1415
1416  pCopyAddFast0(b, a1, monom);  // now a2 != NULL -- set up b
1417
1418  // MAIN LOOP:
1419  Top:     // compare b = monom*a1 and a2 w.r.t. monomial ordering
1420    register long d;
1421    d = pGetOrder(b) - pGetOrder(a2);
1422    NonZeroTestA(d, pOrdSgn, goto NotEqual);
1423    _pMonComp_otEXP_nwEVEN(b, a2, pVariables1W, d, NonZeroA(d, pLexSgn, goto NotEqual ), goto Equal);;
1424
1425  Equal:   // b equals a2
1426    assume(pComp0(b, a2) == 0);
1427    tb = npMultM(pGetCoeff(a1), tm);
1428    tc = pGetCoeff(a2);
1429    if (!npEqualM(tc, tb))
1430    {
1431      tc=npSubM(tc, tb);
1432      ;
1433      pSetCoeff0(a2,tc); // adjust coeff of a2
1434      a = pNext(a) = a2; // append a2 to result and advance a2
1435      pIter(a2);
1436    }
1437    else
1438    { // coeffs are equal, so their difference is 0:
1439      c = a2;  // do not append anything to result: Delete a2 and advance
1440      pIter(a2);
1441      ;
1442      pFree1(c);
1443    }
1444    ;
1445    pIter(a1);
1446    if (a2 == NULL || a1 == NULL) goto Finish; // are we done ?
1447    pCopyAddFast0(b, a1, monom); // No! So, get new b = a1*monom
1448    goto Top;
1449
1450  NotEqual:     // b != a2
1451    if (d < 0)  // b < a2:
1452    {
1453      assume(pComp0(b, a2) == -1);
1454      a = pNext(a) = a2;// append a2 to result and advance a2
1455      pIter(a2);
1456      if (a2==NULL) goto Finish;;
1457      goto Top;
1458    }
1459    else // now d >= 0, i.e., b > a2
1460    {
1461      assume(pComp0(b, a2) == 1);
1462      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
1463      a = pNext(a) = b;       // append b to result and advance a1
1464      pIter(a1);
1465      if (a1 == NULL)         // are we done?
1466      {
1467        b = pNew();
1468        goto Finish;
1469      }
1470      b = pNew();
1471      pCopyAddFast0(b, a1, monom); // No! So, update b = a1*monom
1472      goto Top;
1473    }
1474 
1475 Finish: // a1 or a2 is NULL: Clean-up time
1476   assume(a1 == NULL || a2 == NULL);
1477   if (a1 == NULL) // append rest of a2 to result
1478     pNext(a) = a2;
1479   else  // append (- a1*monom) to result
1480     spMultCopyX(a1, monom, a, tneg, spNoether);
1481   ;
1482   if (b != NULL) pFree1(b);
1483}
1484static void spSpolyLoop_chMODP_otEXP_homGEN_nwODD
1485(poly a1, poly a2, poly monom, poly spNoether)
1486{
1487  poly a = monom,                         // collects the result
1488       b = NULL,                          // stores a1*monom
1489       c;                                 // used for temporary storage
1490  number tm   = pGetCoeff(monom),         // coefficient of monom
1491         tneg = npNegM(tm),        // - (coefficient of monom)
1492         tb,                              // used for tm*coeff(a1)
1493         tc;                              // used for intermediate coeff
1494
1495  Order_t order;                          // used for homog case
1496
1497  if (a2==NULL) goto Finish;              // we are done if a2 is 0
1498  b = pNew();   
1499
1500  ;              // inits order for homog case
1501 
1502
1503  pCopyAddFast0(b, a1, monom);  // now a2 != NULL -- set up b
1504
1505  // MAIN LOOP:
1506  Top:     // compare b = monom*a1 and a2 w.r.t. monomial ordering
1507    register long d;
1508    d = pGetOrder(b) - pGetOrder(a2);
1509    NonZeroTestA(d, pOrdSgn, goto NotEqual);
1510    _pMonComp_otEXP_nwODD(b, a2, pVariables1W, d, NonZeroA(d, pLexSgn, goto NotEqual ), goto Equal);;
1511
1512  Equal:   // b equals a2
1513    assume(pComp0(b, a2) == 0);
1514    tb = npMultM(pGetCoeff(a1), tm);
1515    tc = pGetCoeff(a2);
1516    if (!npEqualM(tc, tb))
1517    {
1518      tc=npSubM(tc, tb);
1519      ;
1520      pSetCoeff0(a2,tc); // adjust coeff of a2
1521      a = pNext(a) = a2; // append a2 to result and advance a2
1522      pIter(a2);
1523    }
1524    else
1525    { // coeffs are equal, so their difference is 0:
1526      c = a2;  // do not append anything to result: Delete a2 and advance
1527      pIter(a2);
1528      ;
1529      pFree1(c);
1530    }
1531    ;
1532    pIter(a1);
1533    if (a2 == NULL || a1 == NULL) goto Finish; // are we done ?
1534    pCopyAddFast0(b, a1, monom); // No! So, get new b = a1*monom
1535    goto Top;
1536
1537  NotEqual:     // b != a2
1538    if (d < 0)  // b < a2:
1539    {
1540      assume(pComp0(b, a2) == -1);
1541      a = pNext(a) = a2;// append a2 to result and advance a2
1542      pIter(a2);
1543      if (a2==NULL) goto Finish;;
1544      goto Top;
1545    }
1546    else // now d >= 0, i.e., b > a2
1547    {
1548      assume(pComp0(b, a2) == 1);
1549      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
1550      a = pNext(a) = b;       // append b to result and advance a1
1551      pIter(a1);
1552      if (a1 == NULL)         // are we done?
1553      {
1554        b = pNew();
1555        goto Finish;
1556      }
1557      b = pNew();
1558      pCopyAddFast0(b, a1, monom); // No! So, update b = a1*monom
1559      goto Top;
1560    }
1561 
1562 Finish: // a1 or a2 is NULL: Clean-up time
1563   assume(a1 == NULL || a2 == NULL);
1564   if (a1 == NULL) // append rest of a2 to result
1565     pNext(a) = a2;
1566   else  // append (- a1*monom) to result
1567     spMultCopyX(a1, monom, a, tneg, spNoether);
1568   ;
1569   if (b != NULL) pFree1(b);
1570}
1571static void spSpolyLoop_chMODP_otEXP_homGEN_nwONE
1572(poly a1, poly a2, poly monom, poly spNoether)
1573{
1574  poly a = monom,                         // collects the result
1575       b = NULL,                          // stores a1*monom
1576       c;                                 // used for temporary storage
1577  number tm   = pGetCoeff(monom),         // coefficient of monom
1578         tneg = npNegM(tm),        // - (coefficient of monom)
1579         tb,                              // used for tm*coeff(a1)
1580         tc;                              // used for intermediate coeff
1581
1582  Order_t order;                          // used for homog case
1583
1584  if (a2==NULL) goto Finish;              // we are done if a2 is 0
1585  b = pNew();   
1586
1587  ;              // inits order for homog case
1588 
1589
1590  pCopyAddFast0(b, a1, monom);  // now a2 != NULL -- set up b
1591
1592  // MAIN LOOP:
1593  Top:     // compare b = monom*a1 and a2 w.r.t. monomial ordering
1594    register long d;
1595    d = pGetOrder(b) - pGetOrder(a2);
1596    NonZeroTestA(d, pOrdSgn, goto NotEqual);
1597    _pMonComp_otEXP_nwONE(b, a2, d, NonZeroA(d, pLexSgn, goto NotEqual ), goto Equal);;
1598
1599  Equal:   // b equals a2
1600    assume(pComp0(b, a2) == 0);
1601    tb = npMultM(pGetCoeff(a1), tm);
1602    tc = pGetCoeff(a2);
1603    if (!npEqualM(tc, tb))
1604    {
1605      tc=npSubM(tc, tb);
1606      ;
1607      pSetCoeff0(a2,tc); // adjust coeff of a2
1608      a = pNext(a) = a2; // append a2 to result and advance a2
1609      pIter(a2);
1610    }
1611    else
1612    { // coeffs are equal, so their difference is 0:
1613      c = a2;  // do not append anything to result: Delete a2 and advance
1614      pIter(a2);
1615      ;
1616      pFree1(c);
1617    }
1618    ;
1619    pIter(a1);
1620    if (a2 == NULL || a1 == NULL) goto Finish; // are we done ?
1621    pCopyAddFast0(b, a1, monom); // No! So, get new b = a1*monom
1622    goto Top;
1623
1624  NotEqual:     // b != a2
1625    if (d < 0)  // b < a2:
1626    {
1627      assume(pComp0(b, a2) == -1);
1628      a = pNext(a) = a2;// append a2 to result and advance a2
1629      pIter(a2);
1630      if (a2==NULL) goto Finish;;
1631      goto Top;
1632    }
1633    else // now d >= 0, i.e., b > a2
1634    {
1635      assume(pComp0(b, a2) == 1);
1636      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
1637      a = pNext(a) = b;       // append b to result and advance a1
1638      pIter(a1);
1639      if (a1 == NULL)         // are we done?
1640      {
1641        b = pNew();
1642        goto Finish;
1643      }
1644      b = pNew();
1645      pCopyAddFast0(b, a1, monom); // No! So, update b = a1*monom
1646      goto Top;
1647    }
1648 
1649 Finish: // a1 or a2 is NULL: Clean-up time
1650   assume(a1 == NULL || a2 == NULL);
1651   if (a1 == NULL) // append rest of a2 to result
1652     pNext(a) = a2;
1653   else  // append (- a1*monom) to result
1654     spMultCopyX(a1, monom, a, tneg, spNoether);
1655   ;
1656   if (b != NULL) pFree1(b);
1657}
1658static void spSpolyLoop_chMODP_otEXP_homGEN_nwTWO
1659(poly a1, poly a2, poly monom, poly spNoether)
1660{
1661  poly a = monom,                         // collects the result
1662       b = NULL,                          // stores a1*monom
1663       c;                                 // used for temporary storage
1664  number tm   = pGetCoeff(monom),         // coefficient of monom
1665         tneg = npNegM(tm),        // - (coefficient of monom)
1666         tb,                              // used for tm*coeff(a1)
1667         tc;                              // used for intermediate coeff
1668
1669  Order_t order;                          // used for homog case
1670
1671  if (a2==NULL) goto Finish;              // we are done if a2 is 0
1672  b = pNew();   
1673
1674  ;              // inits order for homog case
1675 
1676
1677  pCopyAddFast0(b, a1, monom);  // now a2 != NULL -- set up b
1678
1679  // MAIN LOOP:
1680  Top:     // compare b = monom*a1 and a2 w.r.t. monomial ordering
1681    register long d;
1682    d = pGetOrder(b) - pGetOrder(a2);
1683    NonZeroTestA(d, pOrdSgn, goto NotEqual);
1684    _pMonComp_otEXP_nwTWO(b, a2, d, NonZeroA(d, pLexSgn, goto NotEqual ), goto Equal);;
1685
1686  Equal:   // b equals a2
1687    assume(pComp0(b, a2) == 0);
1688    tb = npMultM(pGetCoeff(a1), tm);
1689    tc = pGetCoeff(a2);
1690    if (!npEqualM(tc, tb))
1691    {
1692      tc=npSubM(tc, tb);
1693      ;
1694      pSetCoeff0(a2,tc); // adjust coeff of a2
1695      a = pNext(a) = a2; // append a2 to result and advance a2
1696      pIter(a2);
1697    }
1698    else
1699    { // coeffs are equal, so their difference is 0:
1700      c = a2;  // do not append anything to result: Delete a2 and advance
1701      pIter(a2);
1702      ;
1703      pFree1(c);
1704    }
1705    ;
1706    pIter(a1);
1707    if (a2 == NULL || a1 == NULL) goto Finish; // are we done ?
1708    pCopyAddFast0(b, a1, monom); // No! So, get new b = a1*monom
1709    goto Top;
1710
1711  NotEqual:     // b != a2
1712    if (d < 0)  // b < a2:
1713    {
1714      assume(pComp0(b, a2) == -1);
1715      a = pNext(a) = a2;// append a2 to result and advance a2
1716      pIter(a2);
1717      if (a2==NULL) goto Finish;;
1718      goto Top;
1719    }
1720    else // now d >= 0, i.e., b > a2
1721    {
1722      assume(pComp0(b, a2) == 1);
1723      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
1724      a = pNext(a) = b;       // append b to result and advance a1
1725      pIter(a1);
1726      if (a1 == NULL)         // are we done?
1727      {
1728        b = pNew();
1729        goto Finish;
1730      }
1731      b = pNew();
1732      pCopyAddFast0(b, a1, monom); // No! So, update b = a1*monom
1733      goto Top;
1734    }
1735 
1736 Finish: // a1 or a2 is NULL: Clean-up time
1737   assume(a1 == NULL || a2 == NULL);
1738   if (a1 == NULL) // append rest of a2 to result
1739     pNext(a) = a2;
1740   else  // append (- a1*monom) to result
1741     spMultCopyX(a1, monom, a, tneg, spNoether);
1742   ;
1743   if (b != NULL) pFree1(b);
1744}
1745static void spSpolyLoop_chMODP_otEXP_homYES_nwEVEN
1746(poly a1, poly a2, poly monom, poly spNoether)
1747{
1748  poly a = monom,                         // collects the result
1749       b = NULL,                          // stores a1*monom
1750       c;                                 // used for temporary storage
1751  number tm   = pGetCoeff(monom),         // coefficient of monom
1752         tneg = npNegM(tm),        // - (coefficient of monom)
1753         tb,                              // used for tm*coeff(a1)
1754         tc;                              // used for intermediate coeff
1755
1756  Order_t order;                          // used for homog case
1757
1758  if (a2==NULL) goto Finish;              // we are done if a2 is 0
1759  b = pNew();   
1760
1761  order = pGetOrder(a2);              // inits order for homog case
1762 
1763
1764  pCopyAddFastHomog(b, a1, monom, order);  // now a2 != NULL -- set up b
1765
1766  // MAIN LOOP:
1767  Top:     // compare b = monom*a1 and a2 w.r.t. monomial ordering
1768    register long d;
1769    _pMonComp_otEXP_nwEVEN(b, a2, pVariables1W, d, NonZeroA(d, pLexSgn, goto NotEqual ), goto Equal);;
1770
1771  Equal:   // b equals a2
1772    assume(pComp0(b, a2) == 0);
1773    tb = npMultM(pGetCoeff(a1), tm);
1774    tc = pGetCoeff(a2);
1775    if (!npEqualM(tc, tb))
1776    {
1777      tc=npSubM(tc, tb);
1778      ;
1779      pSetCoeff0(a2,tc); // adjust coeff of a2
1780      a = pNext(a) = a2; // append a2 to result and advance a2
1781      pIter(a2);
1782    }
1783    else
1784    { // coeffs are equal, so their difference is 0:
1785      c = a2;  // do not append anything to result: Delete a2 and advance
1786      pIter(a2);
1787      ;
1788      pFree1(c);
1789    }
1790    ;
1791    pIter(a1);
1792    if (a2 == NULL || a1 == NULL) goto Finish; // are we done ?
1793    pCopyAddFastHomog(b, a1, monom, order); // No! So, get new b = a1*monom
1794    goto Top;
1795
1796  NotEqual:     // b != a2
1797    if (d < 0)  // b < a2:
1798    {
1799      assume(pComp0(b, a2) == -1);
1800      a = pNext(a) = a2;// append a2 to result and advance a2
1801      pIter(a2);
1802      if (a2==NULL) goto Finish;;
1803      goto Top;
1804    }
1805    else // now d >= 0, i.e., b > a2
1806    {
1807      assume(pComp0(b, a2) == 1);
1808      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
1809      a = pNext(a) = b;       // append b to result and advance a1
1810      pIter(a1);
1811      if (a1 == NULL)         // are we done?
1812      {
1813        b = pNew();
1814        goto Finish;
1815      }
1816      b = pNew();
1817      pCopyAddFastHomog(b, a1, monom, order); // No! So, update b = a1*monom
1818      goto Top;
1819    }
1820 
1821 Finish: // a1 or a2 is NULL: Clean-up time
1822   assume(a1 == NULL || a2 == NULL);
1823   if (a1 == NULL) // append rest of a2 to result
1824     pNext(a) = a2;
1825   else  // append (- a1*monom) to result
1826     spMultCopyX(a1, monom, a, tneg, spNoether);
1827   ;
1828   if (b != NULL) pFree1(b);
1829}
1830static void spSpolyLoop_chMODP_otEXP_homYES_nwODD
1831(poly a1, poly a2, poly monom, poly spNoether)
1832{
1833  poly a = monom,                         // collects the result
1834       b = NULL,                          // stores a1*monom
1835       c;                                 // used for temporary storage
1836  number tm   = pGetCoeff(monom),         // coefficient of monom
1837         tneg = npNegM(tm),        // - (coefficient of monom)
1838         tb,                              // used for tm*coeff(a1)
1839         tc;                              // used for intermediate coeff
1840
1841  Order_t order;                          // used for homog case
1842
1843  if (a2==NULL) goto Finish;              // we are done if a2 is 0
1844  b = pNew();   
1845
1846  order = pGetOrder(a2);              // inits order for homog case
1847 
1848
1849  pCopyAddFastHomog(b, a1, monom, order);  // now a2 != NULL -- set up b
1850
1851  // MAIN LOOP:
1852  Top:     // compare b = monom*a1 and a2 w.r.t. monomial ordering
1853    register long d;
1854    _pMonComp_otEXP_nwODD(b, a2, pVariables1W, d, NonZeroA(d, pLexSgn, goto NotEqual ), goto Equal);;
1855
1856  Equal:   // b equals a2
1857    assume(pComp0(b, a2) == 0);
1858    tb = npMultM(pGetCoeff(a1), tm);
1859    tc = pGetCoeff(a2);
1860    if (!npEqualM(tc, tb))
1861    {
1862      tc=npSubM(tc, tb);
1863      ;
1864      pSetCoeff0(a2,tc); // adjust coeff of a2
1865      a = pNext(a) = a2; // append a2 to result and advance a2
1866      pIter(a2);
1867    }
1868    else
1869    { // coeffs are equal, so their difference is 0:
1870      c = a2;  // do not append anything to result: Delete a2 and advance
1871      pIter(a2);
1872      ;
1873      pFree1(c);
1874    }
1875    ;
1876    pIter(a1);
1877    if (a2 == NULL || a1 == NULL) goto Finish; // are we done ?
1878    pCopyAddFastHomog(b, a1, monom, order); // No! So, get new b = a1*monom
1879    goto Top;
1880
1881  NotEqual:     // b != a2
1882    if (d < 0)  // b < a2:
1883    {
1884      assume(pComp0(b, a2) == -1);
1885      a = pNext(a) = a2;// append a2 to result and advance a2
1886      pIter(a2);
1887      if (a2==NULL) goto Finish;;
1888      goto Top;
1889    }
1890    else // now d >= 0, i.e., b > a2
1891    {
1892      assume(pComp0(b, a2) == 1);
1893      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
1894      a = pNext(a) = b;       // append b to result and advance a1
1895      pIter(a1);
1896      if (a1 == NULL)         // are we done?
1897      {
1898        b = pNew();
1899        goto Finish;
1900      }
1901      b = pNew();
1902      pCopyAddFastHomog(b, a1, monom, order); // No! So, update b = a1*monom
1903      goto Top;
1904    }
1905 
1906 Finish: // a1 or a2 is NULL: Clean-up time
1907   assume(a1 == NULL || a2 == NULL);
1908   if (a1 == NULL) // append rest of a2 to result
1909     pNext(a) = a2;
1910   else  // append (- a1*monom) to result
1911     spMultCopyX(a1, monom, a, tneg, spNoether);
1912   ;
1913   if (b != NULL) pFree1(b);
1914}
1915static void spSpolyLoop_chMODP_otEXP_homYES_nwONE
1916(poly a1, poly a2, poly monom, poly spNoether)
1917{
1918  poly a = monom,                         // collects the result
1919       b = NULL,                          // stores a1*monom
1920       c;                                 // used for temporary storage
1921  number tm   = pGetCoeff(monom),         // coefficient of monom
1922         tneg = npNegM(tm),        // - (coefficient of monom)
1923         tb,                              // used for tm*coeff(a1)
1924         tc;                              // used for intermediate coeff
1925
1926  Order_t order;                          // used for homog case
1927
1928  if (a2==NULL) goto Finish;              // we are done if a2 is 0
1929  b = pNew();   
1930
1931  order = pGetOrder(a2);              // inits order for homog case
1932 
1933
1934  pCopyAddFastHomog(b, a1, monom, order);  // now a2 != NULL -- set up b
1935
1936  // MAIN LOOP:
1937  Top:     // compare b = monom*a1 and a2 w.r.t. monomial ordering
1938    register long d;
1939    _pMonComp_otEXP_nwONE(b, a2, d, NonZeroA(d, pLexSgn, goto NotEqual ), goto Equal);;
1940
1941  Equal:   // b equals a2
1942    assume(pComp0(b, a2) == 0);
1943    tb = npMultM(pGetCoeff(a1), tm);
1944    tc = pGetCoeff(a2);
1945    if (!npEqualM(tc, tb))
1946    {
1947      tc=npSubM(tc, tb);
1948      ;
1949      pSetCoeff0(a2,tc); // adjust coeff of a2
1950      a = pNext(a) = a2; // append a2 to result and advance a2
1951      pIter(a2);
1952    }
1953    else
1954    { // coeffs are equal, so their difference is 0:
1955      c = a2;  // do not append anything to result: Delete a2 and advance
1956      pIter(a2);
1957      ;
1958      pFree1(c);
1959    }
1960    ;
1961    pIter(a1);
1962    if (a2 == NULL || a1 == NULL) goto Finish; // are we done ?
1963    pCopyAddFastHomog(b, a1, monom, order); // No! So, get new b = a1*monom
1964    goto Top;
1965
1966  NotEqual:     // b != a2
1967    if (d < 0)  // b < a2:
1968    {
1969      assume(pComp0(b, a2) == -1);
1970      a = pNext(a) = a2;// append a2 to result and advance a2
1971      pIter(a2);
1972      if (a2==NULL) goto Finish;;
1973      goto Top;
1974    }
1975    else // now d >= 0, i.e., b > a2
1976    {
1977      assume(pComp0(b, a2) == 1);
1978      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
1979      a = pNext(a) = b;       // append b to result and advance a1
1980      pIter(a1);
1981      if (a1 == NULL)         // are we done?
1982      {
1983        b = pNew();
1984        goto Finish;
1985      }
1986      b = pNew();
1987      pCopyAddFastHomog(b, a1, monom, order); // No! So, update b = a1*monom
1988      goto Top;
1989    }
1990 
1991 Finish: // a1 or a2 is NULL: Clean-up time
1992   assume(a1 == NULL || a2 == NULL);
1993   if (a1 == NULL) // append rest of a2 to result
1994     pNext(a) = a2;
1995   else  // append (- a1*monom) to result
1996     spMultCopyX(a1, monom, a, tneg, spNoether);
1997   ;
1998   if (b != NULL) pFree1(b);
1999}
2000static void spSpolyLoop_chMODP_otEXP_homYES_nwTWO
2001(poly a1, poly a2, poly monom, poly spNoether)
2002{
2003  poly a = monom,                         // collects the result
2004       b = NULL,                          // stores a1*monom
2005       c;                                 // used for temporary storage
2006  number tm   = pGetCoeff(monom),         // coefficient of monom
2007         tneg = npNegM(tm),        // - (coefficient of monom)
2008         tb,                              // used for tm*coeff(a1)
2009         tc;                              // used for intermediate coeff
2010
2011  Order_t order;                          // used for homog case
2012
2013  if (a2==NULL) goto Finish;              // we are done if a2 is 0
2014  b = pNew();   
2015
2016  order = pGetOrder(a2);              // inits order for homog case
2017 
2018
2019  pCopyAddFastHomog(b, a1, monom, order);  // now a2 != NULL -- set up b
2020
2021  // MAIN LOOP:
2022  Top:     // compare b = monom*a1 and a2 w.r.t. monomial ordering
2023    register long d;
2024    _pMonComp_otEXP_nwTWO(b, a2, d, NonZeroA(d, pLexSgn, goto NotEqual ), goto Equal);;
2025
2026  Equal:   // b equals a2
2027    assume(pComp0(b, a2) == 0);
2028    tb = npMultM(pGetCoeff(a1), tm);
2029    tc = pGetCoeff(a2);
2030    if (!npEqualM(tc, tb))
2031    {
2032      tc=npSubM(tc, tb);
2033      ;
2034      pSetCoeff0(a2,tc); // adjust coeff of a2
2035      a = pNext(a) = a2; // append a2 to result and advance a2
2036      pIter(a2);
2037    }
2038    else
2039    { // coeffs are equal, so their difference is 0:
2040      c = a2;  // do not append anything to result: Delete a2 and advance
2041      pIter(a2);
2042      ;
2043      pFree1(c);
2044    }
2045    ;
2046    pIter(a1);
2047    if (a2 == NULL || a1 == NULL) goto Finish; // are we done ?
2048    pCopyAddFastHomog(b, a1, monom, order); // No! So, get new b = a1*monom
2049    goto Top;
2050
2051  NotEqual:     // b != a2
2052    if (d < 0)  // b < a2:
2053    {
2054      assume(pComp0(b, a2) == -1);
2055      a = pNext(a) = a2;// append a2 to result and advance a2
2056      pIter(a2);
2057      if (a2==NULL) goto Finish;;
2058      goto Top;
2059    }
2060    else // now d >= 0, i.e., b > a2
2061    {
2062      assume(pComp0(b, a2) == 1);
2063      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
2064      a = pNext(a) = b;       // append b to result and advance a1
2065      pIter(a1);
2066      if (a1 == NULL)         // are we done?
2067      {
2068        b = pNew();
2069        goto Finish;
2070      }
2071      b = pNew();
2072      pCopyAddFastHomog(b, a1, monom, order); // No! So, update b = a1*monom
2073      goto Top;
2074    }
2075 
2076 Finish: // a1 or a2 is NULL: Clean-up time
2077   assume(a1 == NULL || a2 == NULL);
2078   if (a1 == NULL) // append rest of a2 to result
2079     pNext(a) = a2;
2080   else  // append (- a1*monom) to result
2081     spMultCopyX(a1, monom, a, tneg, spNoether);
2082   ;
2083   if (b != NULL) pFree1(b);
2084}
2085static spSpolyLoopProc spGetSpolyLoop(Characteristics ch,OrderingTypes ot,Homogs hom,NumWords nw)
2086{
2087if (ch == chMODP)
2088{
2089if (ot == otEXP)
2090{
2091if (hom == homYES)
2092{
2093if (nw == nwTWO)
2094{
2095return spSpolyLoop_chMODP_otEXP_homYES_nwTWO;
2096}
2097if (nw == nwONE)
2098{
2099return spSpolyLoop_chMODP_otEXP_homYES_nwONE;
2100}
2101if (nw == nwODD)
2102{
2103return spSpolyLoop_chMODP_otEXP_homYES_nwODD;
2104}
2105if (nw == nwEVEN)
2106{
2107return spSpolyLoop_chMODP_otEXP_homYES_nwEVEN;
2108}
2109}
2110if (nw == nwTWO)
2111{
2112return spSpolyLoop_chMODP_otEXP_homGEN_nwTWO;
2113}
2114if (nw == nwONE)
2115{
2116return spSpolyLoop_chMODP_otEXP_homGEN_nwONE;
2117}
2118if (nw == nwODD)
2119{
2120return spSpolyLoop_chMODP_otEXP_homGEN_nwODD;
2121}
2122if (nw == nwEVEN)
2123{
2124return spSpolyLoop_chMODP_otEXP_homGEN_nwEVEN;
2125}
2126}
2127if (ot == otEXPCOMP)
2128{
2129if (hom == homYES)
2130{
2131if (nw == nwTWO)
2132{
2133return spSpolyLoop_chMODP_otEXPCOMP_homYES_nwTWO;
2134}
2135if (nw == nwONE)
2136{
2137return spSpolyLoop_chMODP_otEXPCOMP_homYES_nwONE;
2138}
2139if (nw == nwODD)
2140{
2141return spSpolyLoop_chMODP_otEXPCOMP_homYES_nwODD;
2142}
2143if (nw == nwEVEN)
2144{
2145return spSpolyLoop_chMODP_otEXPCOMP_homYES_nwEVEN;
2146}
2147}
2148if (nw == nwTWO)
2149{
2150return spSpolyLoop_chMODP_otEXPCOMP_homGEN_nwTWO;
2151}
2152if (nw == nwONE)
2153{
2154return spSpolyLoop_chMODP_otEXPCOMP_homGEN_nwONE;
2155}
2156if (nw == nwODD)
2157{
2158return spSpolyLoop_chMODP_otEXPCOMP_homGEN_nwODD;
2159}
2160if (nw == nwEVEN)
2161{
2162return spSpolyLoop_chMODP_otEXPCOMP_homGEN_nwEVEN;
2163}
2164}
2165if (ot == otCOMPEXP)
2166{
2167if (hom == homYES)
2168{
2169if (nw == nwTWO)
2170{
2171return spSpolyLoop_chMODP_otCOMPEXP_homYES_nwTWO;
2172}
2173if (nw == nwONE)
2174{
2175return spSpolyLoop_chMODP_otCOMPEXP_homYES_nwONE;
2176}
2177if (nw == nwODD)
2178{
2179return spSpolyLoop_chMODP_otCOMPEXP_homYES_nwODD;
2180}
2181if (nw == nwEVEN)
2182{
2183return spSpolyLoop_chMODP_otCOMPEXP_homYES_nwEVEN;
2184}
2185}
2186if (nw == nwTWO)
2187{
2188return spSpolyLoop_chMODP_otCOMPEXP_homGEN_nwTWO;
2189}
2190if (nw == nwONE)
2191{
2192return spSpolyLoop_chMODP_otCOMPEXP_homGEN_nwONE;
2193}
2194if (nw == nwODD)
2195{
2196return spSpolyLoop_chMODP_otCOMPEXP_homGEN_nwODD;
2197}
2198if (nw == nwEVEN)
2199{
2200return spSpolyLoop_chMODP_otCOMPEXP_homGEN_nwEVEN;
2201}
2202}
2203}
2204return NULL;
2205}
Note: See TracBrowser for help on using the repository browser.