source: git/Singular/spolys.cc @ cc94b0a

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