Context Navigation

spSpolyLoop.inc @ 82ac59

spielwiese

Last change on this file since 82ac59 was 82ac59, checked in by Olaf Bachmann <obachman@…>, 26 years ago
* small bug fix git-svn-id: file:///usr/local/Singular/svn/trunk@1301 2c84dea3-7e68-4137-9b89-c4e89433aadc
Property mode set to `100644`
File size: 69.4 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format