source: git/Singular/spSpolyLoop.inc @ 0498af

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