source: git/Singular/spSpolyLoop.inc @ 82716e

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