Changeset a9c298 in git for kernel/f5gb.cc

Timestamp:

Nov 20, 2013, 4:54:25 PM (10 years ago)

Author:

Hans Schoenemann <hannes@…>

Branches:

(u'spielwiese', '17f1d200f27c5bd38f5dfc6e8a0879242279d1d8')

Children:

0de0509972719531e2a4b51ec9fd0e44a66fd2fd

Parents:

e4014563a82388c4b39dfa37db24cbe159b24a35

git-author:

Hans Schoenemann <hannes@mathematik.uni-kl.de>2013-11-20 16:54:25+01:00

git-committer:

Hans Schoenemann <hannes@mathematik.uni-kl.de>2013-11-20 16:54:42+01:00

Message:

format stuff

File:

• kernel/f5gb.cc (modified) (86 diffs)

kernel/f5gb.cc

@@ -47 +47 @@
 /*
 ====================================================================
-sorting ideals by decreasing total degree "left" and "right" are the 
+sorting ideals by decreasing total degree "left" and "right" are the
 pointer of the first and last polynomial in the considered ideal
 ====================================================================
@@ -59 +59 @@
             while(pTotaldegree(*ptr1, currRing) < pTotaldegree(p2, currRing)) {
                     ptr1++;
-            } 
+            }
             while(pTotaldegree(*ptr2, currRing) > pTotaldegree(p2,currRing)) {
                     ptr2--;
@@ -111 +111 @@
                     return true;
                 }
-            }   
+            }
         }
     }
@@ -119 +119 @@
 /*
 ==================================================
-computes incrementally gbs of subsets of the input 
+computes incrementally gbs of subsets of the input
 gb{f_m} -> gb{f_m,f_(m-1)} -> gb{f_m,...,f_1}
 ==================================================
 */
 LList* F5inc(int i, poly f_i, LList* gPrev, LList* reducers, ideal gbPrev, poly ONE, LTagList* lTag, RList* rules, RTagList* rTag, int plus, int termination) {
-    //Print("in f5inc\n");            
+    //Print("in f5inc\n");
     //pWrite(rules->getFirst()->getRuleTerm());
     int iterationstep = i;
@@ -140 +140 @@
     //Print("2nd gPrev: ");
     //pWrite(gPrev->getFirst()->getNext()->getPoly());
-    //pWrite(gPrev->getFirst()->getNext()->getPoly());    
+    //pWrite(gPrev->getFirst()->getNext()->getPoly());
     CListOld* critPairs        =   new CListOld();
-    CNode* critPairsMinDeg  =   new CNode();   
+    CNode* critPairsMinDeg  =   new CNode();
     PList* rejectedGBList = new PList();
     // computation of critical pairs with checking of criterion 1 and criterion 2 and saving them
@@ -154 +154 @@
     static LList* reducedLPolys     =   new LList();
     // while there are critical pairs to be further checked and deleted/computed
-    while(NULL != critPairs->getFirst()) { 
+    while(NULL != critPairs->getFirst()) {
         // critPairs->getMinDeg() deletes the first elements of minimal degree from
         // critPairs, thus the while loop is not infinite.
-        // adds all to be reduced S-polynomials in the list sPolyList and adds 
+        // adds all to be reduced S-polynomials in the list sPolyList and adds
         // the corresponding rules to the list rules
-        // NOTE: inside there is a second check of criterion 2 if new rules are 
+        // NOTE: inside there is a second check of criterion 2 if new rules are
         // added
         //int timer4  =   initTimer();
@@ -180 +180 @@
             //Print("number of useful pairs:  %d\n",numberUsefulPairs);
             //Print("number of useless pairs: %d\n\n",numberUselessPairs);
-          //Print("Degree of following reduction: %d\n",critPairsMinDeg->getData()->getDeg());  
-        long degreecheck = critPairsMinDeg->getData()->getDeg(); 
-        
+          //Print("Degree of following reduction: %d\n",critPairsMinDeg->getData()->getDeg());
+        long degreecheck = critPairsMinDeg->getData()->getDeg();
+
           computeSPols(critPairsMinDeg,rTag,rules,sPolyList, rejectedGBList);
         //}
@@ -216 +216 @@
         //  return gPrev;
         //}
-        //Print("ARRIS DEG: %ld\n",arrideg); 
+        //Print("ARRIS DEG: %ld\n",arrideg);
         // Arris idea stated by John in an email
         //if(arrisCheck(critPairs->getFirst(),gPrev->getFirst(),arrideg)) {
@@ -222 +222 @@
         //  return gPrev;
         //}
-        
-        
-        //bool aha = checkDGB(gPrev); 
-        
+
+
+        //bool aha = checkDGB(gPrev);
+
 
         //timer3      =  getTimer();
         //reductionTime = reductionTime + timer3;
-        //Print("REDUCTION TIMER: %d\n",timer3); 
+        //Print("REDUCTION TIMER: %d\n",timer3);
         // DEBUG STUFF FOR GPREV
         //temp    =   gPrev->getFirst();
@@ -242 +242 @@
         //}
         //sleep(5);
-    
+
     }
     //Print("REDUCTION DONE\n");
@@ -333 +333 @@
             ppMult_qq(u2,temp2->getPoly()));
         pNorm(sp);
-      
+
         poly reducer  = pOne();
         //reducer       = gb->m[0];
         int i         = 0;
         pWrite(pHead(sp));
-        
+
         while(i<IDELEMS(gb)) {
           reducer = gb->m[i];
@@ -356 +356 @@
           }
         }
-        
+
         pWrite(pHead(sp));
       }
@@ -371 +371 @@
  * Checks all remaining critical pairs, i.e. those of higher degree,
  * by the two Buchberger criteria.
- * return value: 0, if all remaining critical pairs are deleted by 
+ * return value: 0, if all remaining critical pairs are deleted by
  *                  Buchberger's criteria
  *               1, otherwise
@@ -377 +377 @@
 bool arrisCheck(CNode* first, LNode* firstGCurr, long arrideg) {
   CNode* temp = first;
-  
+
   //product criterion check
   while(NULL != temp) {
@@ -422 +422 @@
 }
 
-  
-  
+
+
 /*
 ================================================================
 computes a list of critical pairs for the next reduction process
-the first element is always "useful" thus the critical pair 
-computed is either "useful" or "useless" depending on the second 
+the first element is always "useful" thus the critical pair
+computed is either "useful" or "useless" depending on the second
 element which generates the critical pair.
 first element in gPrev is always the newest element which must
@@ -466 +466 @@
         u2 = pDivide(lcm,pHead(temp->getPoly()));
         pSetCoeff(u2,nOne);
-        int degree = pDeg(ppMult_qq(u2,pHead(temp->getPoly()))); 
+        int degree = pDeg(ppMult_qq(u2,pHead(temp->getPoly())));
         // testing both new labels by the F5 Criterion
         if(!temp->getDel()) {
@@ -473 +473 @@
           }
           if(!criterion2(gPrev->getFirst()->getIndex(), u2, temp, rules, rTag)
-            && !criterion2(gPrev->getFirst()->getIndex(), u1, newElement, rules, rTag) 
+            && !criterion2(gPrev->getFirst()->getIndex(), u1, newElement, rules, rTag)
             && !criterion1(gPrev,u1,newElement,lTag) && !criterion1(gPrev,u2,temp,lTag)) {
               // if they pass the test, add them to CListOld critPairs, having the LPolyOld with greater
               // label as first element in the CPairOld
-              if(newElement->getIndex() == temp->getIndex() && 
+              if(newElement->getIndex() == temp->getIndex() &&
               -1 == pLmCmp(ppMult_qq(u1, newElement->getTerm()),ppMult_qq(u2, temp->getTerm()))) {
-                  CPairOld* cp   =   new CPairOld(pDeg(ppMult_qq(u2,pHead(temp->getPoly()))), u2, 
-                                  temp->getLPolyOld(), u1, newElement->getLPolyOld(), 0 , testedRuleOld);                   
+                  CPairOld* cp   =   new CPairOld(pDeg(ppMult_qq(u2,pHead(temp->getPoly()))), u2,
+                                  temp->getLPolyOld(), u1, newElement->getLPolyOld(), 0 , testedRuleOld);
                   critPairs->insert(cp);
                   // counting the number of useful pairs
@@ -486 +486 @@
               }
               else {
-                  CPairOld* cp   =   new CPairOld(pDeg(ppMult_qq(u2,pHead(temp->getPoly()))), u1, 
-                                  newElement->getLPolyOld(), u2, temp->getLPolyOld(), 0, testedRuleOld);                   
+                  CPairOld* cp   =   new CPairOld(pDeg(ppMult_qq(u2,pHead(temp->getPoly()))), u1,
+                                  newElement->getLPolyOld(), u2, temp->getLPolyOld(), 0, testedRuleOld);
                   critPairs->insert(cp);
                   // counting the number of useful pairs
@@ -511 +511 @@
           //if(rejectedGBList->check(lcm)) { // if there is equality of lcms then we need the F5 critical pair
             if(!criterion2(gPrev->getFirst()->getIndex(), u2, temp, rules, rTag)
-              && !criterion2(gPrev->getFirst()->getIndex(), u1, newElement, rules, rTag) 
+              && !criterion2(gPrev->getFirst()->getIndex(), u1, newElement, rules, rTag)
               && !criterion1(gPrev,u1,newElement,lTag) && !criterion1(gPrev,u2,temp,lTag)) {
                 // if they pass the test, add them to CListOld critPairs, having the LPolyOld with greater
                 // label as first element in the CPairOld
-                if(newElement->getIndex() == temp->getIndex() && 
+                if(newElement->getIndex() == temp->getIndex() &&
                 -1 == pLmCmp(ppMult_qq(u1, newElement->getTerm()),ppMult_qq(u2, temp->getTerm()))) {
-                    CPairOld* cp   =   new CPairOld(pDeg(ppMult_qq(u2,pHead(temp->getPoly()))), u2, 
-                                    temp->getLPolyOld(), u1, newElement->getLPolyOld(), 1 , testedRuleOld);                   
+                    CPairOld* cp   =   new CPairOld(pDeg(ppMult_qq(u2,pHead(temp->getPoly()))), u2,
+                                    temp->getLPolyOld(), u1, newElement->getLPolyOld(), 1 , testedRuleOld);
                     critPairs->insert(cp);
                     numberUselessPairs++;
                 }
                 else {
-                    CPairOld* cp   =   new CPairOld(pDeg(ppMult_qq(u2,pHead(temp->getPoly()))), u1, 
-                                    newElement->getLPolyOld(), u2, temp->getLPolyOld(), 1, testedRuleOld);                   
+                    CPairOld* cp   =   new CPairOld(pDeg(ppMult_qq(u2,pHead(temp->getPoly()))), u1,
+                                    newElement->getLPolyOld(), u2, temp->getLPolyOld(), 1, testedRuleOld);
                     critPairs->insert(cp);
                     numberUselessPairs++;
@@ -540 +540 @@
 ================================================================
 computes a list of critical pairs for the next reduction process
-the first element is always "useless" thus the critical pair 
+the first element is always "useless" thus the critical pair
 computed is "useless".
 first element in gPrev is always the newest element which must
@@ -577 +577 @@
         //if(rejectedGBList->check(lcm)) { // if there is equality of lcms then we need the F5 critical pair
           if(!criterion2(gPrev->getFirst()->getIndex(), u2, temp, rules, rTag)
-            && !criterion2(gPrev->getFirst()->getIndex(), u1, newElement, rules, rTag) 
+            && !criterion2(gPrev->getFirst()->getIndex(), u1, newElement, rules, rTag)
             && !criterion1(gPrev,u1,newElement,lTag) && !criterion1(gPrev,u2,temp,lTag)) {
               // if they pass the test, add them to CListOld critPairs, having the LPolyOld with greater
               // label as first element in the CPairOld
-              if(newElement->getIndex() == temp->getIndex() && 
+              if(newElement->getIndex() == temp->getIndex() &&
               -1 == pLmCmp(ppMult_qq(u1, newElement->getTerm()),ppMult_qq(u2, temp->getTerm()))) {
-                  CPairOld* cp   =   new CPairOld(pDeg(ppMult_qq(u2,pHead(temp->getPoly()))), u2, 
-                                  temp->getLPolyOld(), u1, newElement->getLPolyOld(), 1 , testedRuleOld);                   
+                  CPairOld* cp   =   new CPairOld(pDeg(ppMult_qq(u2,pHead(temp->getPoly()))), u2,
+                                  temp->getLPolyOld(), u1, newElement->getLPolyOld(), 1 , testedRuleOld);
                   critPairs->insert(cp);
                   numberUselessPairs++;
               }
               else {
-                  CPairOld* cp   =   new CPairOld(pDeg(ppMult_qq(u2,pHead(temp->getPoly()))), u1, 
-                                  newElement->getLPolyOld(), u2, temp->getLPolyOld(), 1, testedRuleOld);                   
+                  CPairOld* cp   =   new CPairOld(pDeg(ppMult_qq(u2,pHead(temp->getPoly()))), u1,
+                                  newElement->getLPolyOld(), u2, temp->getLPolyOld(), 1, testedRuleOld);
                   critPairs->insert(cp);
                   numberUselessPairs++;
               }
           }
-        //} 
+        //}
         temp    =   temp->getNext();
     }
@@ -609 +609 @@
 inline bool criterion1(LList* gPrev, poly t, LNode* l, LTagList* lTag) {
     // starts at the first element in gPrev with index = (index of l)-1, these tags are saved in lTag
-        int idx =   l->getIndex();
+    int idx =   l->getIndex();
     int i;
     if(idx == 1) {
@@ -670 +670 @@
 inline bool criterion2(int idx, poly t, LNode* l, RList* rules, RTagList* rTag) {
     //Print("------------------------------IN CRITERION 2/1-----------------------------------------\n");
-    /*  
+    /*
     Print("RULES: \n");
         RNode* tempR    =   rules->getFirst();
@@ -694 +694 @@
         return false;
     }
-    
+
     RNode* testNode; // =   new RNode();
     testNode    =   rules->getFirst();
@@ -706 +706 @@
         }
     }
-    
+
      else {
 
@@ -713 +713 @@
         }
         else {
-       //Print("HIER\n"); 
+       //Print("HIER\n");
             //Print("DEBUG\n");
         //Print("L INDEX: %d\n",l->getIndex());
@@ -731 +731 @@
     */
     //testNode    =   rules->getFirst();
-        // save the monom t1*label_term(l) as it is tested various times in the following
+    // save the monom t1*label_term(l) as it is tested various times in the following
     poly u1 = ppMult_qq(t,l->getTerm());
     // first element added to rTag was NULL, check for this
@@ -738 +738 @@
     //Print("TESTNODE: %p\n",testNode);
     //pWrite(testNode->getRuleTerm());
-    if(NULL != testNode ) {   
+    if(NULL != testNode ) {
         //pWrite(testNode->getRuleTerm());
     }
@@ -750 +750 @@
         }
     }
-    while(NULL != testNode && testNode->getRuleOld() != l->getRuleOld() 
+    while(NULL != testNode && testNode->getRuleOld() != l->getRuleOld()
           && l->getIndex() == testNode->getRuleOldIndex()) {
         //Print("%p\n",testNode);
@@ -765 +765 @@
             return true;
         }
-                testNode    =   testNode->getNext();
+        testNode    =   testNode->getNext();
     }
     //delete testNode;
@@ -798 +798 @@
     */
 // start at the previously added element to gPrev, as all other elements will have the same index for sure
-        RNode* testNode =   rules->getFirst();
+        RNode* testNode =   rules->getFirst();
     // save the monom t1*label_term(l) as it is tested various times in the following
     poly u1 = ppMult_qq(t,l->getTerm());
-        // first element added to rTag was NULL, check for this
-        while(NULL != testNode && testNode->getRuleOld() != testedRuleOld) {
+        // first element added to rTag was NULL, check for this
+        while(NULL != testNode && testNode->getRuleOld() != testedRuleOld) {
         //pWrite(testNode->getRuleTerm());
         if(pLmDivisibleByNoComp(testNode->getRuleOldTerm(),u1)) {
@@ -811 +811 @@
             return true;
         }
-                testNode    =   testNode->getNext();
+                testNode    =   testNode->getNext();
     }
     pDelete(&u1);
@@ -837 +837 @@
 ==================================
 */
-void computeSPols(CNode* first, RTagList* rTag, RList* rules, LList* sPolyList, PList* rejectedGBList) { 
+void computeSPols(CNode* first, RTagList* rTag, RList* rules, LList* sPolyList, PList* rejectedGBList) {
     CNode* temp         =   first;
     //Print("\nDegree:  %d\n",temp->getData()->getDeg());
@@ -850 +850 @@
     CListOld* f5pairs = new CListOld();
     poly sp     =   pInit();
-    number sign =   nInit(-1);   
+    number sign =   nInit(-1);
     //Print("###############################IN SPOLS##############################\n");
     //first->print();
@@ -898 +898 @@
             }
             rejectedGBList->insert(pHead(ppMult_qq(temp->getT1(),temp->getLp1Poly())));
-            //Print("rejected!\n");  
+            //Print("rejected!\n");
 
             //Print("CRITERION 2 in SPOLS 2nd generator\n");
           }
         }
-        else { 
+        else {
           sp      =   ksOldSpolyRedNew(ppMult_qq(temp->getT1(),temp->getLp1Poly()),
               ppMult_qq(temp->getT2(),temp->getLp2Poly()));
@@ -925 +925 @@
         }
       }
-      /*      
+      /*
       if(temp->getDel() == 0 && criterion2(temp->getT1(),temp->getAdLp1(),rules,temp->getTestedRuleOld())) {
-        //Print("rejected!\n");  
+        //Print("rejected!\n");
         rejectedGBList->insert(pHead(ppMult_qq(temp->getT1(),temp->getLp1Poly())));
       }
-      
-       
+
+
       if(temp->getDel() == 1 && !criterion2(temp->getT1(),temp->getAdLp1(),rules,temp->getTestedRuleOld())) {
-        if(highestDegree < pDeg(ppMult_qq(temp->getT1(),temp->getLp1Poly()))) { 
+        if(highestDegree < pDeg(ppMult_qq(temp->getT1(),temp->getLp1Poly()))) {
           highestDegree   = pDeg(ppMult_qq(temp->getT1(),temp->getLp1Poly()));
-        }   
+        }
         if(temp->getLp2Index() == temp->getLp1Index()) {
           if(!criterion2(temp->getT2(),temp->getAdLp2(),rules,temp->getTestedRuleOld())) {
@@ -956 +956 @@
 
               f5rules->insert(rules->getFirst()->getRuleOld());
-              f5pairs->insertWithoutSort(temp->getData());        
+              f5pairs->insertWithoutSort(temp->getData());
               ///////////////////////////////////////
 
@@ -963 +963 @@
           }
         }
-        else { 
+        else {
           sp      =   ksOldSpolyRedNew(ppMult_qq(temp->getT1(),temp->getLp1Poly()),
               ppMult_qq(temp->getT2(),temp->getLp2Poly()));
@@ -983 +983 @@
 
             f5rules->insert(rules->getFirst()->getRuleOld());
-            f5pairs->insertWithoutSort(temp->getData());        
+            f5pairs->insertWithoutSort(temp->getData());
             ///////////////////////////////////////
             //sPolyList->insertByLabel(ppMult_qq(temp->getT1(),temp->getLp1Term()),temp->getLp1Index(),sp,rules->getFirst()->getRuleOld());
@@ -1004 +1004 @@
 
       }
-      
-      /* 
+
+      /*
       temp = f5pairs->getFirst();
       RNode* tempRule = f5rules->getFirst();
@@ -1026 +1026 @@
           numberRejectedF5CriticalPairs++;
               howmany++;
-          if(numberRejectedF5CriticalPairs < -1) { // || 
+          if(numberRejectedF5CriticalPairs < -1) { // ||
           }
           else {
@@ -1050 +1050 @@
             //if(temp->getLp1Index() < 7) {
               sPolyList->insertByLabel(ppMult_qq(temp->getT1(),temp->getLp1Term()),temp->getLp1Index(),sp,tempRule->getRuleOld());
-            
+
             //}
           //numberOfSpolys++;
           }
-        //pSetExp(tempRule->getRuleOld()->getTerm(),1,1000); 
+        //pSetExp(tempRule->getRuleOld()->getTerm(),1,1000);
         }
         temp      = temp->getNext();
@@ -1060 +1060 @@
 
       }
-      */ 
-      // these critical pairs can be deleted now as they are either useless for further computations or 
+      */
+      // these critical pairs can be deleted now as they are either useless for further computations or
       // already saved as an S-polynomial to be reduced in the following
-      delete first;    
+      delete first;
 //Print("NUMBER SPOLYS: %d\n", numberOfSpolys);
 //Print("SPOLY LIST: \n");
@@ -1082 +1082 @@
 ========================================================================
 */
-void reduction(LList* sPolyList, CListOld* critPairs, LList* gPrev, RList* rules, LTagList* lTag, RTagList* rTag, 
-                 ideal gbPrev, PList* rejectedGBList, int plus) { 
+void reduction(LList* sPolyList, CListOld* critPairs, LList* gPrev, RList* rules, LTagList* lTag, RTagList* rTag,
+                 ideal gbPrev, PList* rejectedGBList, int plus) {
     //Print("##########################################In REDUCTION!########################################\n");
     // check if sPolyList has any elements
@@ -1090 +1090 @@
     while(NULL != temp) {
         // temp is the first element in the sPolyList which should be reduced
-        // due to earlier sorting this is the element of minimal degree AND 
+        // due to earlier sorting this is the element of minimal degree AND
         // minimal label
         // delete the above first element from sPolyList, temp will be either reduced to
@@ -1103 +1103 @@
             temp->setPoly(tempNF);
             // try further reductions of temp with polynomials in gPrev
-            // with label index = current label index: this is done such that there 
+            // with label index = current label index: this is done such that there
             // is no label corruption during the reduction process
             //Print("lower label reduction:  ");
             //pWrite(tempNF);
             topReduction(temp,sPolyList,gPrev,critPairs,rules,lTag,rTag,gbPrev, rejectedGBList,plus);
-        
+
         }
         else {
@@ -1121 +1121 @@
     //sPolyList->print();
     //delete sPolyList;
-}    
+}
 
 /*
@@ -1128 +1128 @@
 ========================================================================
 */
-void newReduction(LList* sPolyList, CListOld* critPairs, LList* gPrev, LList* reducers, RList* rules, LTagList* lTag, RTagList* rTag, 
-                 ideal gbPrev, int termination, PList* rejectedGBList, int plus) { 
+void newReduction(LList* sPolyList, CListOld* critPairs, LList* gPrev, LList* reducers, RList* rules, LTagList* lTag, RTagList* rTag,
+                 ideal gbPrev, int termination, PList* rejectedGBList, int plus) {
     //Print("##########################################In REDUCTION!########################################\n");
     // check if sPolyList has any elements
@@ -1139 +1139 @@
         numberOfReductions++;
         // temp is the first element in the sPolyList which should be reduced
-        // due to earlier sorting this is the element of minimal degree AND 
+        // due to earlier sorting this is the element of minimal degree AND
         // minimal label
         // delete the above first element from sPolyList, temp will be either reduced to
@@ -1159 +1159 @@
             //pWrite(tempNF);
             // try further reductions of temp with polynomials in gPrev
-            // with label index = current label index: this is done such that there 
+            // with label index = current label index: this is done such that there
             // is no label corruption during the reduction process
-            findReducers(temp,sPolyList,gbPrev,gPrev,reducers,critPairs,rules,lTag,rTag, termination, rejectedGBList,plus); 
+            findReducers(temp,sPolyList,gbPrev,gPrev,reducers,critPairs,rules,lTag,rTag, termination, rejectedGBList,plus);
         //}
         //else {
@@ -1180 +1180 @@
     //delete sPolyList;
     //Print("REDUCTION FERTIG\n");
-}     
+}
 
 
 /*!
  * ================================================================================
- * searches for reducers of temp similar to the symbolic preprocessing of F4  and 
+ * searches for reducers of temp similar to the symbolic preprocessing of F4  and
  * divides them into a "good" and "bad" part:
- * 
+ *
  * the "good" ones are the reducers which do not corrupt the label of temp, with
  * these the normal form of temp is computed
  *
- * the "bad" ones are the reducers which corrupt the label of temp, they are tested 
+ * the "bad" ones are the reducers which corrupt the label of temp, they are tested
  * later on for possible new rules and S-polynomials to be added to the algorithm
  * ================================================================================
@@ -1259 +1259 @@
                                         break;
                                     }
-                             }    
-                    
+                             }
+
                     }
                     else {
@@ -1267 +1267 @@
                                       //pWrite(u);
                                       //pWrite(tempRed->getTerm());
-                                      //pWrite(pHead(tempRed->getPoly())); 
+                                      //pWrite(pHead(tempRed->getPoly()));
                                       addToG  = 0;
                         }
@@ -1312 +1312 @@
                                         }
                                     }
-                                }    
+                                }
                             }
                             else {
                               //Print("CRIT 1  ");
-                                    
+
                                       if(pLmCmp(ppMult_qq(u,tempRed->getTerm()),l->getTerm()) == 1 ) {
                                       //Print("NOT ALLOWED REDUCER, CRIT 1:\n");
@@ -1369 +1369 @@
                             break;
                         }
-                      
+
                     }
                 }
@@ -1381 +1381 @@
                 //Print("TEMPREDPOLY:  ");
                 //pWrite(tempRed->getPoly());
-              //pWrite(tempPoly);  
+              //pWrite(tempPoly);
               if(pLmDivisibleByNoComp(tempRed->getPoly(),tempPoly)) {
                     //Print("A\n");
@@ -1412 +1412 @@
                                         break;
                                     }
-                             }    
-                    
+                             }
+
                     }
                     else {
@@ -1420 +1420 @@
                                       //pWrite(u);
                                       //pWrite(tempRed->getTerm());
-                                      //pWrite(pHead(tempRed->getPoly())); 
+                                      //pWrite(pHead(tempRed->getPoly()));
                                       //addToG  = 0;
                         }
@@ -1465 +1465 @@
                                         }
                                     }
-                                }    
+                                }
                             }
                             else {
                               //Print("CRIT 1  ");
-                                    
+
                                       if(pLmCmp(ppMult_qq(u,tempRed->getTerm()),l->getTerm()) == 1 ) {
                                       //Print("NOT ALLOWED REDUCER, CRIT 1:\n");
@@ -1498 +1498 @@
                         }
                     }
-                    
+
                 }
                 tempRed =   tempRed->getNext();
@@ -1515 +1515 @@
                // end for top-reduction only
                tempPoly    =   kBucketGetLm(bucket);
-               
+
             }
         }
@@ -1525 +1525 @@
             Print("\nELEMENT ADDED TO GPREV: ");
             pNorm(redPoly);
-              if(highestDegree < pDeg(redPoly)) { 
+              if(highestDegree < pDeg(redPoly)) {
                   highestDegree   = pDeg(redPoly);
-              }   
+              }
             pWrite(pHead(redPoly));
             //pWrite(l->getTerm());
@@ -1567 +1567 @@
             }
         }
-    
+
     // if there are "bad" reducers than try to compute new S-polynomials and rules
-    
+
     if(NULL != bad->getFirst()) {
         //Print("BAD STUFF LIST:\n");
@@ -1608 +1608 @@
                                 //tempRed->getLPoly()->setRule(rules->getFirst()->getRule());
                                 tempBadNew->setDel(1);
-                            
+
                                 sPolyList->insertByLabel(tempBadNew);
                                 //Print("BAD SPOLYLIST: \n");
@@ -1625 +1625 @@
         //Print("HIER AUCH\n");
         //Print("SPOLYLIST IN BAD: \n");
-        //sPolyList->print(); 
+        //sPolyList->print();
     //Print("END FIND REDUCERS\n");
 }
@@ -1713 +1713 @@
             // if label of reductor is greater than the label of l we have to built a new element
             // and add it to sPolyList
-            
+
             if(pLmCmp(tempRed->getTerm(),l->getTerm()) == 1) {
                 // needed sinc pSub destroys the arguments!
@@ -1743 +1743 @@
                 }
             }
-            
-            // label of reductor is smaller than the label of l, subtract reductor from l and delete the 
-            // gPrevRedCheck pointer added to l during findReductor() as the head term of l changes 
-            // after subtraction 
+
+            // label of reductor is smaller than the label of l, subtract reductor from l and delete the
+            // gPrevRedCheck pointer added to l during findReductor() as the head term of l changes
+            // after subtraction
             else {
-                
+
                 //poly temp_poly_l    =   pInit();
                 //temp_poly_l         =   pCopy(l->getPoly());
@@ -1760 +1760 @@
                     pNorm(temp);
                     //pWrite(temp);
-                    poly tempNF =   kNF(gbPrev,currQuotient,temp);  
+                    poly tempNF =   kNF(gbPrev,currQuotient,temp);
                     pNorm(tempNF);
                     if(NULL == tempNF) {
@@ -1769 +1769 @@
                     }
                     l->setPoly(tempNF);
-                    
+
                     gPrevRedCheck   =   lTag->getFirstCurrentIdx();
                 }
@@ -1778 +1778 @@
                     break;
                 }
-            }    
+            }
         }
         else {
@@ -1816 +1816 @@
     poly t      =   pHead(l->getPoly());
     // if l was already checked use the information in gPrevRedCheck such
-    // that we can start searching for new reducers from this point and 
+    // that we can start searching for new reducers from this point and
     // not from the first element of gPrev with the current index
     temp    =   gPrevRedCheck;
@@ -1867 +1867 @@
         temp = temp->getNext();
     }
-    
+
 //    delete temp;
  return NULL;
@@ -1881 +1881 @@
 */
 ideal F5main(ideal id, ring r, int opt, int plus, int termination) {
-  switch(opt) {  
+  switch(opt) {
     case 0:
       Print("\nComputations are done by the standard F5 Algorithm");
@@ -1895 +1895 @@
       return id;
   }
-  
+
     int timer   =   initTimer();
     startTimer();
@@ -1904 +1904 @@
     poly pOne   =   pOne();
     number nOne =   nInit(1);
-    // tag the first element of index i-1 for criterion 1 
+    // tag the first element of index i-1 for criterion 1
     //Print("LTAG BEGINNING: %p\n",lTag);
-    
+
     // DEBUGGING STUFF START
     //Print("NUMBER: %d\n",r->N);
-    /* 
+    /*
     int* ev = new int[r->N +1];
     for(i=0;i<IDELEMS(id);i++) {
@@ -1923 +1923 @@
     */
     /*DEBUGGING STUFF END */
-    
-    // first element in rTag is first element of rules which is NULL RNode, 
+
+    // first element in rTag is first element of rules which is NULL RNode,
     // this must be done due to possible later improvements
     RList* rules    =   new RList();
@@ -1933 +1933 @@
     i = 1;
     /*for(j=0; j<IDELEMS(id); j++) {
-        if(NULL != id->m[j]) { 
+        if(NULL != id->m[j]) {
             if(pComparePolys(id->m[j],ONE)) {
                 Print("One Polynomial in Input => Computations stopped\n");
@@ -1939 +1939 @@
                 idNew->m[0] = ONE;
                 return(idNew);
-            }   
-        }
-    }*/ 
-    ideal idNew     =   kInterRed(id); 
+            }
+        }
+    }*/
+    ideal idNew     =   kInterRed(id);
     id              =   idNew;
     //qsortDegree(&id->m[0],&id->m[IDELEMS(id)-1]);
@@ -1948 +1948 @@
     LList* gPrev    =   new LList(ONE, i, id->m[0]);
     LList* reducers =   new LList();
-    //idShow(id); 
+    //idShow(id);
     //Print("%p\n",id->m[0]);
     //pWrite(id->m[0]);
@@ -1968 +1968 @@
         LNode* gPrevTag =   gPrev->getLast();
         //Print("Last POlynomial in GPREV: ");
-        //Print("%p\n",gPrevTag);    
+        //Print("%p\n",gPrevTag);
         //pWrite(gPrevTag->getPoly());
         Print("Iteration: %d\n\n",i);
@@ -1975 +1975 @@
         //Print("%d\n",gPrev->getLength());
         //Print("____________________________________ITERATION STEP DONE________________________________________\n");
-        
+
         // DEBUGGING STUFF
         LNode* temp    =   gPrev->getFirst();
-    
+
 
         /////////////////////////////////////////////////////////////////////////////////
-        //                                                                             // 
+        //                                                                             //
         // one needs to choose one of the following 3 implementations of the algorithm //
-        // F5,F5R or F5C                                                               // 
+        // F5,F5R or F5C                                                               //
         //                                                                             //
-        /////////////////////////////////////////////////////////////////////////////////                                                                            
-        
-        
-        //   
+        /////////////////////////////////////////////////////////////////////////////////
+
+
+        //
         // standard "F5"
         //
-        if(0 == opt) { 
+        if(0 == opt) {
           if(gPrev->getLength() > gbLength) {
             if(i < IDELEMS(id)) {
@@ -2022 +2022 @@
         gbLength    =   gPrev->getLength();
         }
-        
-
-        // 
+
+
+        //
         //  "F5R"
         //
@@ -2060 +2060 @@
         gbLength    =   gPrev->getLength();
         }
-        
-
-        // 
+
+
+        //
         // "F5C"
         //
-        if(2 == opt) { 
+        if(2 == opt) {
         if(gPrev->getLength() > gbLength) {
             if(i < IDELEMS(id)) {
@@ -2103 +2103 @@
                 }
             }
-            gbLength    =   gPrev->getLength(); 
-        }  
+            gbLength    =   gPrev->getLength();
+        }
         }
 
@@ -2112 +2112 @@
     //Print("\n\nADDING TIME IN REDUCTION: %d\n\n",reductionTime);
     Print("\n\nNumber of zero-reductions:           %d\n",reductionsToZero);
-    Print("Number of rules:                     %d\n",numberOfRules); 
-    Print("Number of rejected F5-critical pairs:%d\n",numberRejectedF5CriticalPairs); 
-    Print("Number of reductions:                %d\n",numberOfReductions); 
-    Print("Elements not added to G:             %d\n",notInG); 
+    Print("Number of rules:                     %d\n",numberOfRules);
+    Print("Number of rejected F5-critical pairs:%d\n",numberRejectedF5CriticalPairs);
+    Print("Number of reductions:                %d\n",numberOfReductions);
+    Print("Elements not added to G:             %d\n",notInG);
     Print("Highest Degree during computations:  %d\n",highestDegree);
     Print("Degree d_0 in F5+:                   %d\n",highestDegreeGBCriticalPair);
@@ -2134 +2134 @@
     highestDegree                 =   0;
     highestDegreeGBCriticalPair   =   0;
-    reductionTime                 =   0; 
+    reductionTime                 =   0;
     spolsTime                     =   0;
     numberUselessPairs            =   0;