Changeset 36ff0ee in git


Ignore:
Timestamp:
Apr 1, 1998, 9:03:22 PM (26 years ago)
Author:
Hans Schönemann <hannes@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'b52fc4b2495505785981d640dcf7eb3e456778ef')
Children:
fca547bc4a4fdc03461b1fa87b33c326d44b5733
Parents:
6ce26066bcd74e6a2cffa12ddab0c5cc98bfb17a
Message:
*** empty log message ***


git-svn-id: file:///usr/local/Singular/svn/trunk@1310 2c84dea3-7e68-4137-9b89-c4e89433aadc
Location:
Singular
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • Singular/ChangeLog

    r6ce260 r36ff0ee  
     1Wed Apr  1 20:55:15 MET DST 1998 hannes
     2        * mpsr_Tok.cc,tok.h: minor fix, removed VERBOSE_CMD
     3        * iparith.cc ipconv.cc: added conversion list <-> resolution
     4        * lists.cc, syz1.cc : fixed bug in conversion (list<->res.):
     5          handling "empty" case
     6        * scanner.l: added option: %option always-interactive 
     7
    18Tue Mar 31 10:47:06 MET DST 1998 hannes
    29        * feread.cc: fixed handling of empty history
  • Singular/spSpolyLoop.inc

    r6ce260 r36ff0ee  
    3131
    3232  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 
     33    assume(pComp0(b, a2) == 0);
    4134    tb = npMultM(pGetCoeff(a1), tm);
    4235    if (!npEqualM(pGetCoeff(a2), tb))
     
    6356    {
    6457      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     }
     58      a = pNext(a) = a2;// append a2 to result and advance a2
     59      pIter(a2);
     60      if (a2==NULL) goto Finish;;
     61      goto Top;
     62    }
     63    else // now d >= 0, i.e., b > a2
     64    {
     65      assume(pComp0(b, a2) == 1);
    8566      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
    8667      a = pNext(a) = b;       // append b to result and advance a1
     
    129110
    130111  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 
     112    assume(pComp0(b, a2) == 0);
    139113    tb = npMultM(pGetCoeff(a1), tm);
    140114    if (!npEqualM(pGetCoeff(a2), tb))
     
    161135    {
    162136      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     }
     137      a = pNext(a) = a2;// append a2 to result and advance a2
     138      pIter(a2);
     139      if (a2==NULL) goto Finish;;
     140      goto Top;
     141    }
     142    else // now d >= 0, i.e., b > a2
     143    {
     144      assume(pComp0(b, a2) == 1);
    183145      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
    184146      a = pNext(a) = b;       // append b to result and advance a1
     
    227189
    228190  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 
     191    assume(pComp0(b, a2) == 0);
    237192    tb = npMultM(pGetCoeff(a1), tm);
    238193    if (!npEqualM(pGetCoeff(a2), tb))
     
    259214    {
    260215      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     }
     216      a = pNext(a) = a2;// append a2 to result and advance a2
     217      pIter(a2);
     218      if (a2==NULL) goto Finish;;
     219      goto Top;
     220    }
     221    else // now d >= 0, i.e., b > a2
     222    {
     223      assume(pComp0(b, a2) == 1);
    281224      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
    282225      a = pNext(a) = b;       // append b to result and advance a1
     
    325268
    326269  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 
     270    assume(pComp0(b, a2) == 0);
    335271    tb = npMultM(pGetCoeff(a1), tm);
    336272    if (!npEqualM(pGetCoeff(a2), tb))
     
    357293    {
    358294      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     }
     295      a = pNext(a) = a2;// append a2 to result and advance a2
     296      pIter(a2);
     297      if (a2==NULL) goto Finish;;
     298      goto Top;
     299    }
     300    else // now d >= 0, i.e., b > a2
     301    {
     302      assume(pComp0(b, a2) == 1);
    379303      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
    380304      a = pNext(a) = b;       // append b to result and advance a1
     
    421345
    422346  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 
     347    assume(pComp0(b, a2) == 0);
    431348    tb = npMultM(pGetCoeff(a1), tm);
    432349    if (!npEqualM(pGetCoeff(a2), tb))
     
    453370    {
    454371      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     }
     372      a = pNext(a) = a2;// append a2 to result and advance a2
     373      pIter(a2);
     374      if (a2==NULL) goto Finish;;
     375      goto Top;
     376    }
     377    else // now d >= 0, i.e., b > a2
     378    {
     379      assume(pComp0(b, a2) == 1);
    475380      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
    476381      a = pNext(a) = b;       // append b to result and advance a1
     
    517422
    518423  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 
     424    assume(pComp0(b, a2) == 0);
    527425    tb = npMultM(pGetCoeff(a1), tm);
    528426    if (!npEqualM(pGetCoeff(a2), tb))
     
    549447    {
    550448      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     }
     449      a = pNext(a) = a2;// append a2 to result and advance a2
     450      pIter(a2);
     451      if (a2==NULL) goto Finish;;
     452      goto Top;
     453    }
     454    else // now d >= 0, i.e., b > a2
     455    {
     456      assume(pComp0(b, a2) == 1);
    571457      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
    572458      a = pNext(a) = b;       // append b to result and advance a1
     
    613499
    614500  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 
     501    assume(pComp0(b, a2) == 0);
    623502    tb = npMultM(pGetCoeff(a1), tm);
    624503    if (!npEqualM(pGetCoeff(a2), tb))
     
    645524    {
    646525      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     }
     526      a = pNext(a) = a2;// append a2 to result and advance a2
     527      pIter(a2);
     528      if (a2==NULL) goto Finish;;
     529      goto Top;
     530    }
     531    else // now d >= 0, i.e., b > a2
     532    {
     533      assume(pComp0(b, a2) == 1);
    667534      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
    668535      a = pNext(a) = b;       // append b to result and advance a1
     
    709576
    710577  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 
     578    assume(pComp0(b, a2) == 0);
    719579    tb = npMultM(pGetCoeff(a1), tm);
    720580    if (!npEqualM(pGetCoeff(a2), tb))
     
    741601    {
    742602      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     }
     603      a = pNext(a) = a2;// append a2 to result and advance a2
     604      pIter(a2);
     605      if (a2==NULL) goto Finish;;
     606      goto Top;
     607    }
     608    else // now d >= 0, i.e., b > a2
     609    {
     610      assume(pComp0(b, a2) == 1);
    763611      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
    764612      a = pNext(a) = b;       // append b to result and advance a1
     
    805653
    806654  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 
     655    assume(pComp0(b, a2) == 0);
    815656    tb = npMultM(pGetCoeff(a1), tm);
    816657    if (!npEqualM(pGetCoeff(a2), tb))
     
    837678    {
    838679      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     }
     680      a = pNext(a) = a2;// append a2 to result and advance a2
     681      pIter(a2);
     682      if (a2==NULL) goto Finish;;
     683      goto Top;
     684    }
     685    else // now d >= 0, i.e., b > a2
     686    {
     687      assume(pComp0(b, a2) == 1);
    859688      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
    860689      a = pNext(a) = b;       // append b to result and advance a1
     
    901730
    902731  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 
     732    assume(pComp0(b, a2) == 0);
    911733    tb = npMultM(pGetCoeff(a1), tm);
    912734    if (!npEqualM(pGetCoeff(a2), tb))
     
    933755    {
    934756      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     }
     757      a = pNext(a) = a2;// append a2 to result and advance a2
     758      pIter(a2);
     759      if (a2==NULL) goto Finish;;
     760      goto Top;
     761    }
     762    else // now d >= 0, i.e., b > a2
     763    {
     764      assume(pComp0(b, a2) == 1);
    955765      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
    956766      a = pNext(a) = b;       // append b to result and advance a1
     
    997807
    998808  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 
     809    assume(pComp0(b, a2) == 0);
    1007810    tb = npMultM(pGetCoeff(a1), tm);
    1008811    if (!npEqualM(pGetCoeff(a2), tb))
     
    1029832    {
    1030833      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     }
     834      a = pNext(a) = a2;// append a2 to result and advance a2
     835      pIter(a2);
     836      if (a2==NULL) goto Finish;;
     837      goto Top;
     838    }
     839    else // now d >= 0, i.e., b > a2
     840    {
     841      assume(pComp0(b, a2) == 1);
    1051842      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
    1052843      a = pNext(a) = b;       // append b to result and advance a1
     
    1093884
    1094885  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 
     886    assume(pComp0(b, a2) == 0);
    1103887    tb = npMultM(pGetCoeff(a1), tm);
    1104888    if (!npEqualM(pGetCoeff(a2), tb))
     
    1125909    {
    1126910      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     }
     911      a = pNext(a) = a2;// append a2 to result and advance a2
     912      pIter(a2);
     913      if (a2==NULL) goto Finish;;
     914      goto Top;
     915    }
     916    else // now d >= 0, i.e., b > a2
     917    {
     918      assume(pComp0(b, a2) == 1);
    1147919      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
    1148920      a = pNext(a) = b;       // append b to result and advance a1
     
    1187959
    1188960  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 
     961    assume(pComp0(b, a2) == 0);
    1197962    tb = npMultM(pGetCoeff(a1), tm);
    1198963    if (!npEqualM(pGetCoeff(a2), tb))
     
    1219984    {
    1220985      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     }
     986      a = pNext(a) = a2;// append a2 to result and advance a2
     987      pIter(a2);
     988      if (a2==NULL) goto Finish;;
     989      goto Top;
     990    }
     991    else // now d >= 0, i.e., b > a2
     992    {
     993      assume(pComp0(b, a2) == 1);
    1241994      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
    1242995      a = pNext(a) = b;       // append b to result and advance a1
     
    12811034
    12821035  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 
     1036    assume(pComp0(b, a2) == 0);
    12911037    tb = npMultM(pGetCoeff(a1), tm);
    12921038    if (!npEqualM(pGetCoeff(a2), tb))
     
    13131059    {
    13141060      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     }
     1061      a = pNext(a) = a2;// append a2 to result and advance a2
     1062      pIter(a2);
     1063      if (a2==NULL) goto Finish;;
     1064      goto Top;
     1065    }
     1066    else // now d >= 0, i.e., b > a2
     1067    {
     1068      assume(pComp0(b, a2) == 1);
    13351069      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
    13361070      a = pNext(a) = b;       // append b to result and advance a1
     
    13751109
    13761110  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 
     1111    assume(pComp0(b, a2) == 0);
    13851112    tb = npMultM(pGetCoeff(a1), tm);
    13861113    if (!npEqualM(pGetCoeff(a2), tb))
     
    14071134    {
    14081135      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     }
     1136      a = pNext(a) = a2;// append a2 to result and advance a2
     1137      pIter(a2);
     1138      if (a2==NULL) goto Finish;;
     1139      goto Top;
     1140    }
     1141    else // now d >= 0, i.e., b > a2
     1142    {
     1143      assume(pComp0(b, a2) == 1);
    14291144      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
    14301145      a = pNext(a) = b;       // append b to result and advance a1
     
    14691184
    14701185  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 
     1186    assume(pComp0(b, a2) == 0);
    14791187    tb = npMultM(pGetCoeff(a1), tm);
    14801188    if (!npEqualM(pGetCoeff(a2), tb))
     
    15011209    {
    15021210      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     }
     1211      a = pNext(a) = a2;// append a2 to result and advance a2
     1212      pIter(a2);
     1213      if (a2==NULL) goto Finish;;
     1214      goto Top;
     1215    }
     1216    else // now d >= 0, i.e., b > a2
     1217    {
     1218      assume(pComp0(b, a2) == 1);
    15231219      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
    15241220      a = pNext(a) = b;       // append b to result and advance a1
     
    15651261
    15661262  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 
     1263    assume(pComp0(b, a2) == 0);
    15751264    tb = npMultM(pGetCoeff(a1), tm);
    15761265    if (!npEqualM(pGetCoeff(a2), tb))
     
    15971286    {
    15981287      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     }
     1288      a = pNext(a) = a2;// append a2 to result and advance a2
     1289      pIter(a2);
     1290      if (a2==NULL) goto Finish;;
     1291      goto Top;
     1292    }
     1293    else // now d >= 0, i.e., b > a2
     1294    {
     1295      assume(pComp0(b, a2) == 1);
    16191296      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
    16201297      a = pNext(a) = b;       // append b to result and advance a1
     
    16611338
    16621339  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 
     1340    assume(pComp0(b, a2) == 0);
    16711341    tb = npMultM(pGetCoeff(a1), tm);
    16721342    if (!npEqualM(pGetCoeff(a2), tb))
     
    16931363    {
    16941364      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     }
     1365      a = pNext(a) = a2;// append a2 to result and advance a2
     1366      pIter(a2);
     1367      if (a2==NULL) goto Finish;;
     1368      goto Top;
     1369    }
     1370    else // now d >= 0, i.e., b > a2
     1371    {
     1372      assume(pComp0(b, a2) == 1);
    17151373      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
    17161374      a = pNext(a) = b;       // append b to result and advance a1
     
    17571415
    17581416  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 
     1417    assume(pComp0(b, a2) == 0);
    17671418    tb = npMultM(pGetCoeff(a1), tm);
    17681419    if (!npEqualM(pGetCoeff(a2), tb))
     
    17891440    {
    17901441      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     }
     1442      a = pNext(a) = a2;// append a2 to result and advance a2
     1443      pIter(a2);
     1444      if (a2==NULL) goto Finish;;
     1445      goto Top;
     1446    }
     1447    else // now d >= 0, i.e., b > a2
     1448    {
     1449      assume(pComp0(b, a2) == 1);
    18111450      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
    18121451      a = pNext(a) = b;       // append b to result and advance a1
     
    18531492
    18541493  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 
     1494    assume(pComp0(b, a2) == 0);
    18631495    tb = npMultM(pGetCoeff(a1), tm);
    18641496    if (!npEqualM(pGetCoeff(a2), tb))
     
    18851517    {
    18861518      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     }
     1519      a = pNext(a) = a2;// append a2 to result and advance a2
     1520      pIter(a2);
     1521      if (a2==NULL) goto Finish;;
     1522      goto Top;
     1523    }
     1524    else // now d >= 0, i.e., b > a2
     1525    {
     1526      assume(pComp0(b, a2) == 1);
    19071527      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
    19081528      a = pNext(a) = b;       // append b to result and advance a1
     
    19471567
    19481568  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 
     1569    assume(pComp0(b, a2) == 0);
    19571570    tb = npMultM(pGetCoeff(a1), tm);
    19581571    if (!npEqualM(pGetCoeff(a2), tb))
     
    19791592    {
    19801593      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     }
     1594      a = pNext(a) = a2;// append a2 to result and advance a2
     1595      pIter(a2);
     1596      if (a2==NULL) goto Finish;;
     1597      goto Top;
     1598    }
     1599    else // now d >= 0, i.e., b > a2
     1600    {
     1601      assume(pComp0(b, a2) == 1);
    20011602      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
    20021603      a = pNext(a) = b;       // append b to result and advance a1
     
    20411642
    20421643  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 
     1644    assume(pComp0(b, a2) == 0);
    20511645    tb = npMultM(pGetCoeff(a1), tm);
    20521646    if (!npEqualM(pGetCoeff(a2), tb))
     
    20731667    {
    20741668      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     }
     1669      a = pNext(a) = a2;// append a2 to result and advance a2
     1670      pIter(a2);
     1671      if (a2==NULL) goto Finish;;
     1672      goto Top;
     1673    }
     1674    else // now d >= 0, i.e., b > a2
     1675    {
     1676      assume(pComp0(b, a2) == 1);
    20951677      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
    20961678      a = pNext(a) = b;       // append b to result and advance a1
     
    21351717
    21361718  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 
     1719    assume(pComp0(b, a2) == 0);
    21451720    tb = npMultM(pGetCoeff(a1), tm);
    21461721    if (!npEqualM(pGetCoeff(a2), tb))
     
    21671742    {
    21681743      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     }
     1744      a = pNext(a) = a2;// append a2 to result and advance a2
     1745      pIter(a2);
     1746      if (a2==NULL) goto Finish;;
     1747      goto Top;
     1748    }
     1749    else // now d >= 0, i.e., b > a2
     1750    {
     1751      assume(pComp0(b, a2) == 1);
    21891752      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
    21901753      a = pNext(a) = b;       // append b to result and advance a1
     
    22291792
    22301793  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 
     1794    assume(pComp0(b, a2) == 0);
    22391795    tb = npMultM(pGetCoeff(a1), tm);
    22401796    if (!npEqualM(pGetCoeff(a2), tb))
     
    22611817    {
    22621818      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     }
     1819      a = pNext(a) = a2;// append a2 to result and advance a2
     1820      pIter(a2);
     1821      if (a2==NULL) goto Finish;;
     1822      goto Top;
     1823    }
     1824    else // now d >= 0, i.e., b > a2
     1825    {
     1826      assume(pComp0(b, a2) == 1);
    22831827      pSetCoeff0(b,npMultM(pGetCoeff(a1), tneg));
    22841828      a = pNext(a) = b;       // append b to result and advance a1
Note: See TracChangeset for help on using the changeset viewer.