source: git/Singular/spolys.cc @ f92fa13

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