source: git/Singular/spolys0.cc @ 6f2edc

spielwiese
Last change on this file since 6f2edc was 32df82, checked in by Hans Schönemann <hannes@…>, 27 years ago
* hannes: removed rcsid and Log: entries, added assignment module=poly corected type conversion int->module git-svn-id: file:///usr/local/Singular/svn/trunk@128 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 16.9 KB
Line 
1/****************************************
2*  Computer Algebra System SINGULAR     *
3****************************************/
4/* $Id: spolys0.cc,v 1.3 1997-04-02 15:07:54 Singular Exp $ */
5
6/*
7* ABSTRACT - s-polynomials and reduction in general
8*/
9
10#include <string.h>
11#include "mod2.h"
12#include "tok.h"
13#include "mmemory.h"
14#include "numbers.h"
15#include "polys.h"
16#include "spolys0.h"
17
18/*0 implementation*/
19
20/*
21* input - output: a, b
22* returns:
23*   a := a/gcd(a,b), b := b/gcd(a,b)
24*   and return value
25*       0  ->  a != 1,  b != 1
26*       1  ->  a == 1,  b != 1
27*       2  ->  a != 1,  b == 1
28*       3  ->  a == 1,  b == 1
29*   this value is used to control the spolys
30*/
31static int spCheckCoeff(number *a, number *b)
32{
33  int c = 0;
34  number an = *a, bn = *b, cn = nGcd(an, bn);
35
36  if(nIsOne(cn))
37  {
38    an = nCopy(an);
39    bn = nCopy(bn);
40  }
41  else
42  {
43    an = nIntDiv(an, cn);
44    bn = nIntDiv(bn, cn);
45  }
46  nDelete(&cn);
47  if (nIsOne(an))
48  {
49    c = 1;
50  }
51  if (nIsOne(bn))
52  {
53    c += 2;
54  }
55  *a = an;
56  *b = bn;
57  return c;
58}
59
60/*2
61* transforms a1 to a polynomial
62*/
63void spModuleToPoly(poly a1)
64{
65#ifdef PDEBUG
66  poly t=a1;
67  pTest(t);
68#endif
69  do
70  {
71    pSetComp(a1,0);
72    pIter(a1);
73  } while (a1!=NULL);
74#ifdef PDEBUG
75  pTest(t);
76#endif
77}
78
79/*2
80* assume m = L(m) and Lc(m) = 1
81* pNext(m) = result = p*m
82* do not destroy p
83*/
84static void spGMultCopy0(poly p, poly m, poly spNoether)
85{
86  poly a, b;
87
88  a = m;
89  if (spNoether==NULL)
90  {
91    do
92    {
93      a = pNext(a) = pNew();
94      spMemcpy(a,p);
95      spMonAdd(a,m);
96      pSetCoeff0(a,nCopy(pGetCoeff(a)));
97      pIter(p);
98    }
99    while (p!=NULL);
100    pNext(a) = NULL;
101    return;
102  }
103  else
104  {
105    do
106    {
107      b = pNext(a) = pNew();
108      spMemcpy(b,p);
109      spMonAdd(b,m);
110      if (pComp0(b, spNoether) == -1)
111      {
112        pFree1(b);
113        pNext(a) = NULL;
114        return;
115      }
116      a = b;
117      pSetCoeff0(a,nCopy(pGetCoeff(a)));
118      pIter(p);
119    } while (p!=NULL);
120    pNext(a) = NULL;
121  }
122}
123
124/*2
125* assume m = L(m) and Lc(m) = -1
126* pNext(n) = result = p*m
127* do not destroy p
128*/
129static void spGMultCopy1(poly p, poly m, poly n,poly spNoether)
130{
131  poly a, b;
132
133  a = n;
134  if (spNoether==NULL)
135  {
136    do
137    {
138      number tmp;
139      a = pNext(a) = pNew();
140      spMemcpy(a,p);
141      spMonAdd(a,m);
142      tmp=nCopy(pGetCoeff(a));
143      tmp=nNeg(tmp);
144      pSetCoeff0(a,tmp);
145      pIter(p);
146    }
147    while (p!=NULL);
148    pNext(a) = NULL;
149    return;
150  }
151  else
152  {
153    do
154    {
155      b = pNext(a) = pNew();
156      spMemcpy(b,p);
157      spMonAdd(b,m);
158      if (pComp(b, spNoether) == -1)
159      {
160        pFree1(b);
161        pNext(a) = NULL;
162        return;
163      }
164      a = b;
165      number tmp;
166      tmp=nCopy(pGetCoeff(a));
167      tmp=nNeg(tmp);
168      pSetCoeff0(a,tmp);
169      pIter(p);
170    }
171    while (p!=NULL);
172    pNext(a) = NULL;
173  }
174}
175
176/*2
177* assume m = L(m) and Lc(m) = 1
178* pNext(m) = result = a2-a1*m
179* do not destroy a1, but a2
180*/
181static void spGSpolyLoop1(poly a1, poly a2, poly m, poly spNoether)
182{
183  poly a, b, s;
184  number tb;
185  int c;
186
187  if (a2==NULL)
188  {
189    spGMultCopy1(a1, m, m,spNoether);
190    return;
191  }
192  a = m;
193  b = pNew();
194  spMemcpy(b,a1);
195  spMonAdd(b,m);
196  loop
197  {
198    c = pComp0(b, a2);
199    if (c == 1)
200    {
201      number tmp=nCopy(pGetCoeff(b));
202      tmp=nNeg(tmp);
203      pSetCoeff0(b,tmp);
204      a = pNext(a) = b;
205      pIter(a1);
206      if (a1!=NULL)
207      {
208        b = pNew();
209        spMemcpy(b,a1);
210        spMonAdd(b,m);
211      }
212      else
213      {
214        pNext(a) = a2;
215        return;
216      }
217    }
218    else if (c == -1)
219    {
220      a = pNext(a) = a2;
221      pIter(a2);
222      if (a2==NULL)
223      {
224        pFree1(b);
225        spGMultCopy1(a1, m, a,spNoether);
226        return;
227      }
228    }
229    else
230    {
231      tb = pGetCoeff(a2);
232      if (!nEqual(tb,pGetCoeff(a1)))
233      {
234        tb = nSub(tb,pGetCoeff(a1));
235        pSetCoeff(a2,tb);
236        a = pNext(a) = a2;
237        pIter(a2);
238      }
239      else
240      {
241        s = a2;
242        pIter(a2);
243        nDelete(&tb);
244        pFree1(s);
245      }
246      pIter(a1);
247      if (a1==NULL)
248      {
249        pFree1(b);
250        pNext(a) = a2;
251        return;
252      }
253      if (a2==NULL)
254      {
255        pFree1(b);
256        spGMultCopy1(a1, m, a,spNoether);
257        return;
258      }
259      spMemcpy(b,a1);
260      spMonAdd(b,m);
261    }
262  }
263}
264
265/*2
266* assume m = L(m) and Lc(m) = exp
267* pNext(n) = result = p*m
268* do not destroy p
269*/
270static void spGMultCopyX(poly p, poly m, poly n, number exp, poly spNoether)
271{
272  poly a, b;
273
274  a = n;
275  if (spNoether==NULL)
276  {
277    do
278    {
279      a = pNext(a) = pNew();
280      spMemcpy(a,p);
281      spMonAdd(a,m);
282      pSetCoeff0(a,nMult(pGetCoeff(p),exp));
283      pIter(p);
284    } while (p!=NULL);
285    pNext(a) = NULL;
286    return;
287  }
288  else
289  {
290    do
291    {
292      b = pNext(a) = pNew();
293      spMemcpy(b,p);
294      spMonAdd(b,m);
295      if (pComp(b, spNoether) == -1)
296      {
297        pFree1(b);
298        pNext(a) = NULL;
299        return;
300      }
301      a = b;
302      pSetCoeff0(a,nMult(pGetCoeff(p),exp));
303      pIter(p);
304    } while (p!=NULL);
305    pNext(a) = NULL;
306  }
307}
308
309/*2
310* assume m = L(m)
311* pNext(m) = result = a2-a1*m
312* do not destroy a1, but a2
313*/
314static void spGSpolyLoop(poly a1, poly a2, poly m,poly spNoether)
315{
316  poly a, b, s;
317  number tm = pGetCoeff(m);
318  number tneg,tb,t;
319  int c;
320
321  tneg = nCopy(tm);
322  tneg = nNeg(tneg);
323  if (a2==NULL)
324  {
325    spGMultCopyX(a1, m, m, tneg,spNoether);
326    nDelete(&tneg);
327    return;
328  }
329  a = m;
330  b = pNew();
331  spMemcpy(b,a1);
332  spMonAdd(b,m);
333  loop
334  {
335    c = pComp0(b, a2);
336    if (c == 1)
337    {
338      pSetCoeff0(b,nMult(pGetCoeff(a1),tneg));
339      a = pNext(a) = b;
340      pIter(a1);
341      if (a1!=NULL)
342      {
343        b = pNew();
344        spMemcpy(b,a1);
345        spMonAdd(b,m);
346      }
347      else
348      {
349        pNext(a) = a2;
350        nDelete(&tneg);
351        return;
352      }
353    }
354    else if (c == -1)
355    {
356      a = pNext(a) = a2;
357      pIter(a2);
358      if (a2==NULL)
359      {
360        pFree1(b);
361        spGMultCopyX(a1, m, a, tneg,spNoether);
362        nDelete(&tneg);
363        return;
364      }
365    }
366    else
367    {
368      t = pGetCoeff(a2);
369      tb = nMult(pGetCoeff(a1),tm);
370      if (!nEqual(t,tb))
371      {
372        t = nSub(t,tb);
373        pSetCoeff(a2,t);
374        a = pNext(a) = a2;
375        pIter(a2);
376      }
377      else
378      {
379        s = a2;
380        pIter(a2);
381        nDelete(&t);
382        pFree1(s);
383      }
384      nDelete(&tb);
385      pIter(a1);
386      if (a1==NULL)
387      {
388        pFree1(b);
389        pNext(a) = a2;
390        nDelete(&tneg);
391        return;
392      }
393      if (a2==NULL)
394      {
395        pFree1(b);
396        spGMultCopyX(a1, m, a, tneg,spNoether);
397        nDelete(&tneg);
398        return;
399      }
400      spMemcpy(b,a1);
401      spMonAdd(b,m);
402    }
403  }
404}
405
406/*2
407* reduction of p2 with p1
408* do not destroy p1, but p2
409*/
410poly spGSpolyRed(poly p1, poly p2,poly spNoether)
411{
412  poly a1 = pNext(p1), a2 = pNext(p2);
413  number an = pGetCoeff(p1), bn = pGetCoeff(p2);
414  int ct = spCheckCoeff(&an, &bn);
415
416  pSetCoeff(p2,bn);
417  if(a1==NULL)
418  {
419    nDelete(&an);
420    nDelete(&bn);
421    pFree1(p2);
422    return a2;
423  }
424  if ((ct == 0) || (ct == 2))
425  {
426    pMultN(a2, an);
427  }
428  nDelete(&an);
429  BOOLEAN reset_vec=FALSE;
430  if (pGetComp(p1) != pGetComp(p2))
431  {
432    pSetCompP(a1,pGetComp(p2));
433    reset_vec=TRUE;
434  }
435  spMonSub(p2,p1);
436  if (ct < 2)
437  {
438    spGSpolyLoop(a1, a2, p2,spNoether);
439  }
440  else
441  {
442    spGSpolyLoop1(a1, a2, p2,spNoether);
443  }
444  a2 = pNext(p2);
445  if (reset_vec)
446  {
447    spModuleToPoly(a1);
448  }
449  nDelete(&bn);
450  pFree1(p2);
451  return a2;
452}
453
454/*2
455* reduction of tail(q) with p1
456* lead(p1) divides lead(pNext(q2)) and pNext(q2) is reduced
457* do not destroy p1, but tail(q)
458*/
459void spGSpolyTail(poly p1, poly q, poly q2, poly spNoether)
460{
461  number t;
462  poly m, h;
463  poly a1 = pNext(p1), p2 = pNext(q2), a2 = pNext(p2);
464  number an = pGetCoeff(p1), bn = pGetCoeff(p2);
465  int ct = spCheckCoeff(&an, &bn);
466  BOOLEAN reset_vec=FALSE;
467
468  if(a1==NULL)
469  {
470    nDelete(&an);
471    nDelete(&bn);
472    nDelete(&pGetCoeff(p2));
473    pFree1(p2);
474    pNext(q2) = a2;
475    return;
476  }
477  if (p1 != q)
478  {
479    m = p2;
480    pSetCoeff(m,bn);
481  }
482  else
483  {
484    m = pNew();
485    spMemcpy(m,p2);
486    pSetCoeff0(m,bn);
487    a2 = pCopy(a2);
488  }
489  if ((ct == 0) || (ct == 2))
490  {
491    pMultN(a2, an);
492  }
493  if ((pGetComp(p1) != pGetComp(p2))
494  && (pGetComp(p1)==0))
495  {
496    pSetCompP(a1,pGetComp(p2));
497    reset_vec=TRUE;
498  }
499  spMonSub(m,p1);
500  if (ct < 2)
501  {
502    spGSpolyLoop(a1, a2, m,spNoether);
503  }
504  else
505  {
506    spGSpolyLoop1(a1, a2, m,spNoether);
507  }
508  if ((ct == 0) || (ct == 2))
509  {
510    h = q;
511    do
512    {
513      t = nMult(pGetCoeff(h),an);
514      pSetCoeff(h,t);
515      pIter(h);
516    }
517    while (h != p2);
518  }
519  h = pNext(m);
520  nDelete(&an);
521  nDelete(&bn);
522  pFree1(m);
523  pNext(q2) = h;
524  if (reset_vec)
525    spModuleToPoly(a1);
526  if (p1 == q)
527  {
528    pDelete(&p2);
529  }
530}
531
532/*2
533* reduction of p2 with p1
534* do not destroy p1 and p2
535*/
536poly spGSpolyRedNew(poly p1, poly p2,poly spNoether)
537{
538  poly m;
539  poly a1 = pNext(p1), a2 = pNext(p2);
540  number an = pGetCoeff(p1), bn = pGetCoeff(p2);
541  int ct = spCheckCoeff(&an, &bn);
542
543  if(a1==NULL)
544  {
545    nDelete(&an);
546    nDelete(&bn);
547    return pCopy(a2);
548  }
549  if ((ct == 0) || (ct == 2))
550  {
551    a2 = pMultCopyN(a2,an);
552  }
553  else
554  {
555    a2 = pCopy(a2);
556  }
557  nDelete(&an);
558  BOOLEAN reset_vec=FALSE;
559  if (pGetComp(p1) != pGetComp(p2))
560  {
561    pSetCompP(a1,pGetComp(p2));
562    reset_vec=TRUE;
563  }
564  m = pNew();
565  spMemcpy(m,p2);
566  spMonSub(m,p1);
567  if (ct < 2)
568  {
569    pSetCoeff0(m,bn);
570    spGSpolyLoop(a1, a2, m,spNoether);
571  }
572  else
573  {
574    spGSpolyLoop1(a1, a2, m,spNoether);
575  }
576  a2 = pNext(m);
577  if (reset_vec)
578  {
579    spModuleToPoly(a1);
580  }
581  nDelete(&bn);
582  pFree1(m);
583  return a2;
584}
585
586/*2
587* creates the S-polynomial of p1 and p2
588* do not destroy p1 and p2
589*/
590poly spGSpolyCreate(poly p1, poly p2,poly spNoether)
591{
592  short x;
593  poly m, b;
594  poly a1 = pNext(p1), a2 = pNext(p2);
595  number an = pGetCoeff(p1), bn = pGetCoeff(p2);
596  int co=0, ct = spCheckCoeff(&an, &bn);
597
598  if (pGetComp(p1)!=pGetComp(p2))
599  {
600    if (pGetComp(p1)==0)
601    {
602      co=1;
603      pSetCompP(p1,pGetComp(p2));
604    }
605    else
606    {
607      co=2;
608      pSetCompP(p2,pGetComp(p1));
609    }
610  }
611  b = pNew();
612  m = pNew();
613  for (int i = pVariables; i; i--)
614  {
615    x = pGetExp(p1,i) - pGetExp(p2,i);
616    if (x > 0)
617    {
618      pSetExp(b,i,x);
619      pSetExp(m,i,0);
620    }
621    else
622    {
623      pSetExp(m,i,-x);
624      pSetExp(b,i,0);
625    }
626  }
627  pSetm(m);
628  pSetm(b);
629  if (a2!=NULL)
630  {
631    if ((ct == 0) || (ct == 2))
632    {
633      spGMultCopyX(a2, b, b, an,spNoether);
634    }
635    else
636    {
637      spGMultCopy0(a2, b,spNoether);
638    }
639    a2 = pNext(b);
640  }
641  nDelete(&an);
642  pFree1(b);
643  if (a1!=NULL)
644  {
645    if (ct < 2)
646    {
647      pSetCoeff0(m,bn);
648      spGSpolyLoop(a1, a2, m,spNoether);
649    }
650    else
651    {
652      spGSpolyLoop1(a1, a2, m,spNoether);
653    }
654    a2 = pNext(m);
655  }
656  nDelete(&bn);
657  pFree1(m);
658  if (co != 0)
659  {
660    if (co==1)
661    {
662      spModuleToPoly(p1);
663    }
664    else
665    {
666      spModuleToPoly(p2);
667    }
668  }
669  return a2;
670}
671
672void spShort1(poly b, poly a, poly m)
673{
674  for(int i=pVariables; i; i--)
675  {
676    if(pGetExp(m,i)<0)
677    {
678      pSetExp(b,i,pGetExp(a,i));
679    }
680  }
681  pFree1(m);
682  pSetm(b);
683}
684
685void spShort2(poly b, poly a, poly m)
686{
687  short x;
688  pSetComp(b,pGetComp(a));
689  for(int i=pVariables; i; i--)
690  {
691    if(pGetExp(m,i)<0)
692      x = pGetExp(a,i)-pGetExp(m,i);
693    else
694      x = pGetExp(a,i);
695    pSetExp(b,i,x);
696  }
697  pFree1(m);
698  pSetm(b);
699}
700
701/*2
702* creates the leading term of the S-polynomial of p1 and p2
703* do not destroy p1 and p2
704* remarks:
705*   1. the coefficient is 0 (nNew)
706*   2. in a first step the monomials from p1 are
707*      multiplied with L(p2-p1), hence the multiplication
708*      must be additive and further the transformation
709*      spShort1 and spShort2 are needed
710*/
711poly spGSpolyShortBba(poly p1, poly p2)
712{
713  poly a1 = pNext(p1), a2 = pNext(p2);
714  poly m,b;
715  number ta,tb,t;
716  int c;
717  int co=0;
718  if (pGetComp(p1)!=pGetComp(p2))
719  {
720    if (pGetComp(p1)==0)
721    {
722      co=1;
723      pSetCompP(p1,pGetComp(p2));
724    }
725    else
726    {
727      co=2;
728      pSetCompP(p2,pGetComp(p1));
729    }
730  }
731  b = pNew();
732  m = pNew();
733  pSetComp(b,pGetComp(p1));
734  spMemcpy(m,p2);
735  spMonSub(m,p1);
736  if(a1!=NULL)
737  {
738    spMemcpy(b,a1);
739    spMonAdd(b,m);
740    if(a2==NULL)
741    {
742      spShort1(b,a1,m);
743      nNew(&(pGetCoeff(b)));
744      if (co==1) spModuleToPoly(p1);
745      else if (co==2) spModuleToPoly(p2);
746      return b;
747    }
748  }
749  else
750  {
751    if(a2!=NULL)
752    {
753      spShort2(b,a2,m);
754      nNew(&(pGetCoeff(b)));
755      if (co==1) spModuleToPoly(p1);
756      else if (co==2) spModuleToPoly(p2);
757      return b;
758    }
759    else
760    {
761      pFree1(m);
762      pFree1(b);
763      if (co==1) spModuleToPoly(p1);
764      else if (co==2) spModuleToPoly(p2);
765      return NULL;
766    }
767  }
768  loop
769  {
770    c = pComp0(b,a2);
771    if (c == 1)
772    {
773      spShort1(b,a1,m);
774      nNew(&(pGetCoeff(b)));
775      break;
776    }
777    else if (c == -1)
778    {
779      spShort2(b,a2,m);
780      nNew(&(pGetCoeff(b)));
781      break;
782    }
783    else
784    {
785      if (nIsOne(pGetCoeff(p1)))
786      {
787        if (nIsOne(pGetCoeff(p2)))
788          t = nSub(pGetCoeff(a2), pGetCoeff(a1));
789        else
790        {
791          ta = nMult(pGetCoeff(a1), pGetCoeff(p2));
792          t = nSub(ta, pGetCoeff(a2));
793          nDelete(&ta);
794        }
795      }
796      else
797      {
798        if (nIsOne(pGetCoeff(p2)))
799        {
800          ta = nMult(pGetCoeff(a2), pGetCoeff(p1));
801          t = nSub(ta, pGetCoeff(a1));
802        }
803        else
804        {
805          ta = nMult(pGetCoeff(a1), pGetCoeff(p2));
806          tb = nMult(pGetCoeff(a2), pGetCoeff(p1));
807          t = nSub(ta, tb);
808          nDelete(&tb);
809        }
810        nDelete(&ta);
811      }
812      if (!nIsZero(t))
813      {
814        nDelete(&t);
815        spShort1(b,a1,m);
816        nNew(&(pGetCoeff(b)));
817        break;
818      }
819      nDelete(&t);
820      pIter(a2);
821      pIter(a1);
822      if(a1!=NULL)
823      {
824        spMemcpy(b,a1);
825        spMonAdd(b,m);
826        if(a2==NULL)
827        {
828          spShort1(b,a1,m);
829          nNew(&(pGetCoeff(b)));
830          break;
831        }
832      }
833      else
834      {
835        if(a2!=NULL)
836        {
837          spShort2(b,a2,m);
838          nNew(&(pGetCoeff(b)));
839          break;
840        }
841        else
842        {
843          pFree1(m);
844          pFree1(b);
845          b= NULL; break;
846        }
847      }
848    }
849  }
850  if (co==1) spModuleToPoly(p1);
851  else if (co==2) spModuleToPoly(p2);
852  return b;
853}
854
855/*2
856* creates the last term of the S-polynomial of p1 and p2
857* in order to compute the ecart
858* do not destroy p1 and p2
859* remarks:
860*   1. the coefficient is undefined
861*   2. see above
862*/
863/*
864*static poly spGSpolyLast(poly p1, poly p2)
865*{
866*  poly a1 = pNext(p1), a2 = pNext(p2);
867*  poly m, b, L1, L2;
868*  number ta,tb,t;
869*  int c;
870*
871*  m = pNew();
872*  b = pNew();
873*  spMemcpy(m,p2);
874*  spMonSub(m,p1);
875*  pSetComp(b,pGetComp(p1));
876*  if (a2)
877*  {
878*    while (pNext(a2))
879*      pIter(a2);
880*  }
881*  if (a1)
882*  {
883*    while (pNext(a1))
884*      pIter(a1);
885*    spMemcpy(b,a1);
886*    spMonAdd(b,m);
887*  }
888*  else
889*  {
890*    spShort2(b,a2,m);
891*    return b;
892*  }
893*  if(!a2)
894*  {
895*    spShort1(b,a1,m);
896*    return b;
897*  }
898*  for (; ; )
899*  {
900*    c = pComp0(b, a2);
901*    if (c == -1)
902*    {
903*      spShort1(b,a1,m);
904*      return b;
905*    }
906*    else if (c == 1)
907*    {
908*      spShort2(b,a2,m);
909*      return b;
910*    }
911*    else
912*    {
913*      if (nIsOne(pGetCoeff(p1)))
914*      {
915*        if (nIsOne(pGetCoeff(p2)))
916*          t = nSub(pGetCoeff(a2), pGetCoeff(a1));
917*        else
918*        {
919*          ta = nMult(pGetCoeff(a1), pGetCoeff(p2));
920*          t = nSub(ta, pGetCoeff(a2));
921*          nDelete(&ta);
922*        }
923*      }
924*      else
925*      {
926*        if (nIsOne(pGetCoeff(p2)))
927*        {
928*          ta = nMult(pGetCoeff(a2), pGetCoeff(p1));
929*          t = nSub(ta, pGetCoeff(a1));
930*        }
931*        else
932*        {
933*          ta = nMult(pGetCoeff(a1), pGetCoeff(p2));
934*          tb = nMult(pGetCoeff(a2), pGetCoeff(p1));
935*          t = nSub(ta, tb);
936*          nDelete(&tb);
937*        }
938*        nDelete(&ta);
939*      }
940*      if (!nIsZero(t))
941*      {
942*        nDelete(&t);
943*        spShort1(b,a1,m);
944*        return b;
945*      }
946*      nDelete(&t);
947*      if (a1 != pNext(p1))
948*      {
949*        L1 = a1;
950*        a1 = pNext(p1);
951*        while (pNext(a1) != L1)
952*          pIter(a1);
953*        spMemcpy(b,a1);
954*        spMonAdd(b,m);
955*      }
956*      if (a2 != pNext(p2))
957*      {
958*        L2 = a2;
959*        a2 = pNext(p2);
960*        while (pNext(a2) != L2)
961*          pIter(a2);
962*      }
963*    }
964*  }
965*}
966*/
967/*2
968* creates the leading term of the S-polynomial of p1 and p2
969* and computes the ecart under the assumtion that
970* the last term of the S-polynomial is the greatest
971* do not destroy p1 and p2
972*/
973/*
974*poly spGSpolyShortMora(poly p1, poly p2, int *ecart)
975*{
976*  poly p, q;
977*
978*  p = spGSpolyShortBba(p1, p2, ecart);
979*  *ecart = 0;
980*  if(p)
981*  {
982*    if(spNoether==NULL)
983*    {
984*      q = spGSpolyLast(p1, p2);
985*      *ecart = pFDeg(q) - pFDeg(p);
986*      pFree1(q);
987*      return p;
988*    }
989*    if (pComp(p, spNoether) == -1)
990*    {
991*      pFree1(p);
992*      return NULL;
993*    }
994*    q = spGSpolyLast(p1, p2);
995*    if (pComp(q, spNoether) == -1)
996*      *ecart = pFDeg(spNoether) - pFDeg(p);
997*    else
998*      *ecart = pFDeg(q) - pFDeg(p);
999*    pFree1(q);
1000*  }
1001*  return p;
1002*}
1003*/
Note: See TracBrowser for help on using the repository browser.