Changeset 5812c69 in git

Timestamp:

Sep 24, 1998, 11:59:51 AM (25 years ago)

Author:

Hans Schönemann <hannes@…>

Branches:

(u'spielwiese', '8d54773d6c9e2f1d2593a28bc68b7eeab54ed529')

Children:

56c52a7879fbc6de62cefba1da86b2edf2aadd4c

Parents:

073d2edeb03013a5c6ed0913687b024305a1427d

Message:

cosmetic changes


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

Location:

Singular

Files:

• LIB/primdec.lib (modified) (4 diffs)
• clapconv.cc (modified) (2 diffs)
• claptmpl.cc (modified) (2 diffs)
• cntrlc.cc (modified) (8 diffs)
• comm.cc (modified) (21 diffs)
• comm.h (modified) (1 diff)
• fglmcomb.cc (modified) (6 diffs)
• fglmgauss.cc (modified) (9 diffs)
• fglmhom.cc (modified) (10 diffs)
• fglmvec.cc (modified) (23 diffs)
• fglmzero.cc (modified) (54 diffs)
• getopt.h (modified) (6 diffs)
• hdegree.cc (modified) (6 diffs)
• hutil.cc (modified) (3 diffs)
• intvec.cc (modified) (4 diffs)
• ipconv.cc (modified) (3 diffs)
• ipid.cc (modified) (4 diffs)
• ipid.h (modified) (2 diffs)
• khstd.cc (modified) (3 diffs)
• lists.cc (modified) (2 diffs)
• longalg.cc (modified) (2 diffs)
• maps.cc (modified) (2 diffs)
• mmalloc.c (modified) (2 diffs)

Singular/LIB/primdec.lib

@@ -1 @@
-// $Id: primdec.lib,v 1.25 1998-08-05 11:12:32 Singular Exp $
+// $Id: primdec.lib,v 1.26 1998-09-24 09:59:51 Singular Exp $
 ////////////////////////////////////////////////////////////////////////////////
 // primdec.lib                                                                //
@@ -11 +11 @@
 ////////////////////////////////////////////////////////////////////////////////
 
-version="$Id: primdec.lib,v 1.25 1998-08-05 11:12:32 Singular Exp $";
+version="$Id: primdec.lib,v 1.26 1998-09-24 09:59:51 Singular Exp $";
 info="
 LIBRARY: primdec.lib: PROCEDURE FOR PRIMARY DECOMPOSITION
@@ -383 +383 @@
    if(size(k1)==size(k2))
    {
-      for(j=1;j<=size(k1);j++)
+      for(j=size(k1);j>0;j--)
       {
          if(leadexp(k1[j])!=leadexp(k2[j]))
@@ -401 +401 @@
    if(size(k1)==size(k2))
    {
-      for(j=1;j<=size(k1);j++)
+      for(j=size(k1);j>0;j--)
       {
          if(leadexp(k1[j])!=leadexp(k2[j]))

Singular/clapconv.cc

@@ -3 +3 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-// $Id: clapconv.cc,v 1.17 1998-04-27 14:47:01 Singular Exp $
+// $Id: clapconv.cc,v 1.18 1998-09-24 09:59:34 Singular Exp $
 /*
 * ABSTRACT: convert data between Singular and factory
@@ -164 +164 @@
     {
       result = pAdd( result, term );
-    }  
+    }
   }
 }

Singular/claptmpl.cc

@@ -3 +3 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-// $Id: claptmpl.cc,v 1.17 1998-06-30 16:30:05 schmidt Exp $
+// $Id: claptmpl.cc,v 1.18 1998-09-24 09:59:35 Singular Exp $
 /*
 * ABSTRACT - instantiation of all templates
@@ -94 +94 @@
 {
     if ( this != &f ) {
-        _factor = f._factor;
-        _exp = f._exp;
+        _factor = f._factor;
+        _exp = f._exp;
     }
     return *this;

Singular/cntrlc.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: cntrlc.cc,v 1.19 1998-07-30 17:49:15 Singular Exp $ */
+/* $Id: cntrlc.cc,v 1.20 1998-09-24 09:59:36 Singular Exp $ */
 /*
 * ABSTRACT - interupt handling
@@ -62 +62 @@
 BOOLEAN siCntrlc = FALSE;
 
+typedef void (*si_hdl_typ)(int);
+
 /*0 implementation*/
 #ifndef MSDOS
@@ -67 +69 @@
 #ifndef macintosh
 /* signals are not right implemented in macintosh */
-typedef void (*si_hdl_typ)(int);
 void sigint_handler(int sig);
 #endif
@@ -124 +125 @@
   }
 #endif
-#ifdef HAVE_FEREAD
-  fe_reset_input_mode();
-#endif
 #ifndef __OPTIMIZE__
   if (sig!=SIGINT) debug(INTERACTIVE);
@@ -216 +214 @@
     PrintS("cannot set signal handler for IOT\n");
   }
+#ifndef macintosh
   if (SIG_ERR==signal(SIGINT ,sigint_handler))
   {
     PrintS("cannot set signal handler for INT\n");
   }
+#endif
 }
 
@@ -245 +245 @@
     longjmp(si_start_jmpbuf,1);
   }
-#endif
-#ifdef HAVE_FEREAD
-  fe_reset_input_mode(0,NULL);
 #endif
 #ifndef __OPTIMIZE__
@@ -292 +289 @@
     longjmp(si_start_jmpbuf,1);
   }
-#endif
-#ifdef HAVE_FEREAD
-#ifdef HAVE_ATEXIT
-  fe_reset_input_mode();
-#else
-  fe_reset_input_mode(0,NULL);
-#endif
 #endif
 #ifdef unix
@@ -439 +429 @@
 //}
 //#endif
-
-#ifndef MSDOS
-// /*2
-// * test for SIGINT, start an interpreter
-// */
-// void test_int_std(leftv v)
-// {
-// #ifndef macintosh
-// //#ifdef macintosh
-// //  beachball();
-// //#endif
-//   if (siCntrlc>1)
-//   {
-//     int saveecho = si_echo;
-//     siCntrlc = FALSE;
-//     signal(SIGINT ,sigint_handler);
-// //#ifdef macintosh
-// //    flush_intr();
-// //#endif
-//     //si_echo = 2;
-//     printf("\n//inside a computation, continue with `exit;`\n");
-//     iiPStart("STDIN","STDIN",NULL);
-//     si_echo = saveecho;
-//   }
-// #endif
-// }
-#endif
 
 #ifndef MSDOS

Singular/comm.cc

@@ -52 +52 @@
       delete(res);
     }
-    
+
   Free((ADDRESS)Warteliste,(Wartelistemax)*sizeof(LObject));
 }
@@ -135 +135 @@
 //   PrintS("Restore\n");
   if(DEBUG) PrintS("Restore\n");
-  
+
   int i = 0;
   int l = 0;
@@ -141 +141 @@
     {
       while(i<aktuell)
-        {
-          l = strat->posInL(strat->L,strat->Ll,Warteliste[i],strat);
-          enterL(&(strat->L),&(strat->Ll),&(strat->Lmax),Warteliste[i++],l);
-        }
-      
+        {
+          l = strat->posInL(strat->L,strat->Ll,Warteliste[i],strat);
+          enterL(&(strat->L),&(strat->Ll),&(strat->Lmax),Warteliste[i++],l);
+        }
+
       aktuell=0;
       return TRUE;
@@ -180 +180 @@
       lv->rtyp = INTVEC_CMD;
       switch(msg)
-        {
-
-        case MsgTupel:
-          for(i=0; i<pVariables; i++)
-            exp[i+1]=pGetExp(strat->P.p, i+1);
-          break;
-
-        case MsgTupelPosition:
-          for(i=0; i<pVariables; i++)
-            exp[i+1]=0;
-
-          // Neue Position von strat->P.p bestimmen
-          pos=-1;
-          for(i=strat->Ll-1; i>=0; i--)
-            {
-              if((strat->L[i].p1 == strat->P.p1) && (strat->L[i].p2 == strat->P.p2))
-                { 
-                  pos = i;
-                  continue;
-                }
-            }
-          exp[1]=pos;
-          break;
-
-        default:
-          for(i=0; i<pVariables; i++)
-            exp[i+1]=0;
-          break;
-        }
+        {
+
+        case MsgTupel:
+          for(i=0; i<pVariables; i++)
+            exp[i+1]=pGetExp(strat->P.p, i+1);
+          break;
+
+        case MsgTupelPosition:
+          for(i=0; i<pVariables; i++)
+            exp[i+1]=0;
+
+          // Neue Position von strat->P.p bestimmen
+          pos=-1;
+          for(i=strat->Ll-1; i>=0; i--)
+            {
+              if((strat->L[i].p1 == strat->P.p1) && (strat->L[i].p2 == strat->P.p2))
+                {
+                  pos = i;
+                  continue;
+                }
+            }
+          exp[1]=pos;
+          break;
+
+        default:
+          for(i=0; i<pVariables; i++)
+            exp[i+1]=0;
+          break;
+        }
       lv->data=ivCopy(&exp);
       if(li==-1)
-        {
-          for(i=0; i< procnum; i++)
-            if((*links)[i]!=NULL)
-              slWrite((*links)[i], lv);
-        }
+        {
+          for(i=0; i< procnum; i++)
+            if((*links)[i]!=NULL)
+              slWrite((*links)[i], lv);
+        }
       else
-        {
-          slWrite((*links)[li], lv);
-        }
+        {
+          slWrite((*links)[li], lv);
+        }
       lv->CleanUp();
       Free(lv,sizeof(sleftv));
@@ -235 +235 @@
       intvec *rec = NULL;
       if(DEBUG) PrintS("ReceiveMsg\n");
-  
+
       leftv lv = NULL;
       for(int i=0; i<procnum;i++)
-        {
-          lv=slRead((*links)[i]);
-          rec=ivCopy((intvec *) lv->Data());
-          if((*res)[i]!=NULL)
-            {
-              delete (*res)[i];
-              (*res)[i]=NULL;
-            }
-          (*msg)[i] = (*rec)[0];
-          if((stdMsg)(*msg)[i]==MsgTupel)
-            {
-              (*res)[i] = new intvec(pVariables,1,0);
-              for(int j = 0; j<pVariables ; j++)
-                (*(*res)[i])[j]=(*rec)[j+1];
-            }
-        }
+        {
+          lv=slRead((*links)[i]);
+          rec=ivCopy((intvec *) lv->Data());
+           if((*res)[i]!=NULL)
+             {
+               delete (*res)[i];
+               (*res)[i]=NULL;
+             }
+          (*msg)[i] = (*rec)[0];
+          if((stdMsg)(*msg)[i]==MsgTupel)
+            {
+              (*res)[i] = new intvec(pVariables,1,0);
+              for(int j = 0; j<pVariables ; j++)
+                (*(*res)[i])[j]=(*rec)[j+1];
+            }
+        }
         lv->CleanUp();
         Free(lv, sizeof(sleftv));
@@ -259 +259 @@
       delete rec;
       if(DEBUG) PrintS("ReceiveMsg Ende\n");
-      return TRUE;  
+      return TRUE;
     }
 }
@@ -286 +286 @@
     case ModWrite:
     case ModRun:  // Berechne und sende Tupel
-      Verwaltung  = TRUE;     
-      Receive     = FALSE;    
-      TupelL      = TRUE;     
-      SPoly       = TRUE;     
-      Reduzieren  = TRUE;     
-      TupelMelden = TRUE;     
-      TupelTesten = FALSE;    
+      Verwaltung  = TRUE;
+      Receive     = FALSE;
+      TupelL      = TRUE;
+      SPoly       = TRUE;
+      Reduzieren  = TRUE;
+      TupelMelden = TRUE;
+      TupelTesten = FALSE;
       TupelPosition = TRUE;
-      ResultSend  = FALSE;    
-      TupelStore  = FALSE;    
+      ResultSend  = FALSE;
+      TupelStore  = FALSE;
       break;
     case ModStep:  // Warte auf MsgStep, berechne und sende
-      Verwaltung  = TRUE;     
-      Receive     = TRUE;    
-      TupelL      = TRUE;     
-      SPoly       = TRUE;     
-      Reduzieren  = TRUE;     
-      TupelMelden = TRUE;     
+      Verwaltung  = TRUE;
+      Receive     = TRUE;
+      TupelL      = TRUE;
+      SPoly       = TRUE;
+      Reduzieren  = TRUE;
+      TupelMelden = TRUE;
       TupelPosition = TRUE;
-      TupelTesten = FALSE;    
-      ResultSend  = TRUE;    
-      TupelStore  = FALSE;    
+      TupelTesten = FALSE;
+      ResultSend  = TRUE;
+      TupelStore  = FALSE;
       break;
     case ModCalc: // Warte auf Tupel und berechne
-      Verwaltung  = TRUE; 
-      Receive     = TRUE;    
-      TupelL      = TRUE;     
-      TupelMelden = FALSE;    
+      Verwaltung  = TRUE;
+      Receive     = TRUE;
+      TupelL      = TRUE;
+      TupelMelden = FALSE;
       TupelPosition = FALSE;
       ResultSend  = TRUE;
       TupelStore  = (*msg)[0]==MsgTupelisZero;
       if(TupelStore)
-        {
-          SPoly      = FALSE; 
-          Reduzieren = FALSE;
-          TupelTesten = FALSE;
-        }
+        {
+           SPoly      = FALSE;
+           Reduzieren = FALSE;
+           TupelTesten = FALSE;
+        }
       else
-        {
-          SPoly      = TRUE;  
-          Reduzieren = TRUE;  
-          TupelTesten = TRUE;
-        }
+        {
+          SPoly      = TRUE;
+          Reduzieren = TRUE;
+          TupelTesten = TRUE;
+        }
       break;
     case ModPosition: // Tupel neu positionieren
-      Verwaltung  = TRUE; 
-      Receive     = TRUE;    
-      TupelL      = TRUE;     
-      TupelMelden = FALSE;    
+      Verwaltung  = TRUE;
+      Receive     = TRUE;
+      TupelL      = TRUE;
+      TupelMelden = FALSE;
       TupelPosition = FALSE;
       ResultSend  = TRUE;
@@ -345 +345 @@
       Restore(strat);
       if(strat->Ll>=0)
-        {
-          Verwaltung  = TRUE;
-          Receive     = FALSE;
-          TupelL      = TRUE;
-          TupelStore  = FALSE;    
-          SPoly       = TRUE;
-          TupelMelden = FALSE;
-          TupelPosition = FALSE;
-          TupelTesten = FALSE;
-          ResultSend  = TRUE;
-          Reduzieren  = TRUE;
-        }
+        {
+          Verwaltung  = TRUE;
+          Receive     = FALSE;
+          TupelL      = TRUE;
+          TupelStore  = FALSE;
+          SPoly       = TRUE;
+          TupelMelden = FALSE;
+          TupelPosition = FALSE;
+          TupelTesten = FALSE;
+          ResultSend  = TRUE;
+          Reduzieren  = TRUE;
+        }
       else
-        {
-          SetModus(ModEnde,strat);
-        }
+        {
+          SetModus(ModEnde,strat);
+        }
       break;
     case ModEnde:  //sofort beenden
       Verwaltung  = FALSE;
-      Receive     = FALSE;    
-      TupelWarte  = FALSE;    
-      TupelL      = FALSE;    
-      TupelStore  = FALSE;    
-      TupelTesten = FALSE;    
-      SPoly       = FALSE;    
-      Reduzieren  = FALSE;    
-      TupelMelden = FALSE;    
-      ResultSend  = FALSE;    
+      Receive     = FALSE;
+      TupelWarte  = FALSE;
+      TupelL      = FALSE;
+      TupelStore  = FALSE;
+      TupelTesten = FALSE;
+      SPoly       = FALSE;
+      Reduzieren  = FALSE;
+      TupelMelden = FALSE;
+      ResultSend  = FALSE;
       break;
     }
@@ -396 +396 @@
     case ModCalc:   // Beenden erst dann, wenn Calc2 erreicht ist.
       SetModus(ModCalc);
-      if(strat->Ll<0) 
-        {
-          if(BTEST1(OPT_INTERRUPT))
-            return TRUE;
-          if(TEST_OPT_PROT)
+      if(strat->Ll<0)
+        {
+          if(BTEST1(OPT_INTERRUPT))
+            return TRUE;
+          if(TEST_OPT_PROT)
             {
-              PrintS("\n<C>\n");
+              PrintS("\n<C>\n");
               writeTime("used time: #");
             }
-          SetModus(ModCheck,strat);
-        }
-        return FALSE;
+           SetModus(ModCheck,strat);
+        }
+        return FALSE;
       break;
     case ModCheck:
@@ -436 +436 @@
     {
       if(strat->Ll != oldLl )
-        {
-          SendMsg(strat, MsgTupelPosition);
-          TupelMelden = FALSE;
-        }
-    }
-  
+        {
+          SendMsg(strat, MsgTupelPosition);
+          TupelMelden = FALSE;
+        }
+    }
+
 }
 
@@ -460 +460 @@
 //   PrintS("ParseMessage\n");
   if(DEBUG) PrintS("ParseMessage\n");
-  BOOLEAN err=FALSE; 
+  BOOLEAN err=FALSE;
   // Testen, ob alle Nachrichten korrekt sind,
   // wenn ja, dann ParseMessageFinal
   // sonst die richtige finden, andere Prozesse killen
-  
+
   // Ist nur ein proc vorhanden, dann automatisch weiter
-  for(int i=1; i< procnum; i++)  
+  for(int i=1; i< procnum; i++)
     err = err || ((*msg)[i] != (*msg)[0]);
   if(!err)
@@ -477 +477 @@
       // Unterschiedliche Tupel : In TupelDifferent alle abweichler killen
       for(int i=0; i<procnum; i++)
-        if(((stdMsg)(*msg)[i]) == MsgTupelisZero)
-          {
-            PrintS(" AAA ");
-            KillChild(strat,i);
-          }
+        if(((stdMsg)(*msg)[i]) == MsgTupelisZero)
+          {
+            PrintS(" AAA ");
+             KillChild(strat,i);
+          }
       ParseMessageFinal(strat);
     }
@@ -493 +493 @@
 //   PrintS("ParseMessageFinal\n");
   if(DEBUG) PrintS("ParseMessageFinal\n");
-  
+
   switch(((stdMsg) (*msg)[i]))
     {
-    case MsgTupel:  // In Step-Modus schalten bzw. bleiben.     
+    case MsgTupel:  // In Step-Modus schalten bzw. bleiben.
     case MsgTupelisZero:
 
        if(procnum>0)
-        {
-          SetModus(ModCalc,strat);
-        }
+         {
+           SetModus(ModCalc,strat);
+         }
        else
-        {
-          SetModus(ModCheck,strat);
-        }
+         {
+           SetModus(ModCheck,strat);
+         }
       break;
     case MsgTupelPosition:
       // aktuelles Tupel neu positionieren
       if(TEST_OPT_PROT)
-        PrintS("P");
+        PrintS("P");
       SetModus(ModPosition);
       break;
-     case MsgEnd:  // In Calc1-Modus schalten bzw. bleiben.     
+     case MsgEnd:  // In Calc1-Modus schalten bzw. bleiben.
        SetModus(ModCheck,strat);
        if (TEST_OPT_PROT) PrintS("\n<E>");
@@ -534 +534 @@
     {
       if(strat->P.p==NULL)
-        {
-          PrintS(" BBB ");
-          KillChild(strat,i);
-        }
+        {
+          PrintS(" BBB ");
+           KillChild(strat,i);
+        }
       else
-        {
-          if((*res)[i]==NULL)
-            {
-              PrintS(" CCC ");
-              KillChild(strat,i);
-            }
-          else
-            {
-              Different = FALSE;
-              for(int j=0; j< pVariables; j++)
-                {
-                  Different = Different || ((*(*res)[i])[j]!=pGetExp(strat->P.p,j+1));
-                }
-              if(Different)
-                {
-                  PrintS(" DDD ");
-                  KillChild(strat,i);
-                }
-            }
-        }
+        {
+          if((*res)[i]==NULL)
+            {
+              PrintS(" CCC ");
+               KillChild(strat,i);
+            }
+          else
+            {
+              Different = FALSE;
+              for(int j=0; j< pVariables; j++)
+                {
+                  Different = Different || ((*(*res)[i])[j]!=pGetExp(strat->P.p,j+1));
+                }
+              if(Different)
+                {
+                  PrintS(" DDD ");
+                   KillChild(strat,i);
+                }
+            }
+        }
     }
   if(procnum<=0)
@@ -587 +587 @@
      {
        if(procnum>=2)
-        {
-          si_link swaplink = (*links)[li];
-          intvec *swapres = (*res)[li];
-          (*msg)[li]   = (*msg)[procnum-1];
-          (*links)[li] = (*links)[procnum-1];
-          (*res)[li]   = (*res)[procnum-1];
-          (*links)[procnum-1] = swaplink;
-          (*res)[procnum-1]   = swapres;
-        }
+         {
+            si_link swaplink = (*links)[li];
+            intvec *swapres = (*res)[li];
+            (*msg)[li]   = (*msg)[procnum-1];
+            (*links)[li] = (*links)[procnum-1];
+            (*res)[li]   = (*res)[procnum-1];
+            (*links)[procnum-1] = swaplink;
+            (*res)[procnum-1]   = swapres;
+         }
         else
-          {
-            if(TEST_OPT_PROT)
-              {
-                PrintS("\n<K>\n");
-                writeTime("used time: #");
-              }
-            SetModus(ModCheck,strat);
-          }
+          {
+            if(TEST_OPT_PROT)
+              {
+                PrintS("\n<K>\n");
+                writeTime("used time: #");
+              }
+            SetModus(ModCheck,strat);
+          }
        procnum--;
      }
@@ -610 +610 @@
      {
        for(int i=procnum - 1 ; i>=0 ; i--)
-        KillChild(strat,i,Cancled);
+         KillChild(strat,i,Cancled);
      }
  }
@@ -620 +620 @@
     if(lnModus==lnRead)
       {
-        SetModus(ModCalc);
+        SetModus(ModCalc);
       }
     else
       {
-        SetModus(ModRun  );
+        SetModus(ModRun  );
       }
 }
@@ -646 +646 @@
       l->Init(aktuell);
       for(i=0; i<aktuell; i++)
-        {
-          I=idInit(2,1);
-          l->m[i].rtyp = IDEAL_CMD;
-          if(Warteliste[i].p1==NULL)
-            I->m[0]=NULL;
-          else
-            I->m[0]=pCopy(Warteliste[i].p1);
-          if(Warteliste[i].p2==NULL)
-            I->m[1]=NULL;
-          else
-            I->m[1]=pCopy(Warteliste[i].p2);
-          l->m[i].data = (void *) idCopy(I);
-          idDelete(&I);
-        }
+        {
+           I=idInit(2,1);
+          l->m[i].rtyp = IDEAL_CMD;
+          if(Warteliste[i].p1==NULL)
+            I->m[0]=NULL;
+          else
+            I->m[0]=pCopy(Warteliste[i].p1);
+          if(Warteliste[i].p2==NULL)
+            I->m[1]=NULL;
+          else
+            I->m[1]=pCopy(Warteliste[i].p2);
+           l->m[i].data = (void *) idCopy(I);
+            idDelete(&I);
+        }
       return l;
     }
@@ -667 +667 @@
       return l;
     }
-  
+
 }
 
@@ -677 +677 @@
 //       Print("r(%.5i) Msg =",-1);
       switch(msg) {
-      case MsgTupelisZero:  // In Step-Modus schalten bzw. bleiben.     
-        PrintS("MsgTupelisZero ");
-        break;
-      case MsgTupel:  // In Step-Modus schalten bzw. bleiben.     
-        PrintS("MsgTupel       ");
-        break;
+      case MsgTupelisZero:  // In Step-Modus schalten bzw. bleiben.
+        PrintS("MsgTupelisZero ");
+        break;
+      case MsgTupel:  // In Step-Modus schalten bzw. bleiben.
+        PrintS("MsgTupel       ");
+        break;
       case MsgEnd:
-        PrintS("MsgEnd         ");
-        break;
+        PrintS("MsgEnd         ");
+        break;
       }
     }
 }
- 
+
 void skstdLink::DispMod(int i)
 {
@@ -695 +695 @@
     {
       Print("r(%.5i) Mod = ",-1);
-      
+
       switch(Modus) {
       case ModCheck:
-        PrintS("Check ");
-        break;
+        PrintS("Check ");
+        break;
       case ModRun:
-        PrintS("Run   ");
-        break;
+        PrintS("Run   ");
+        break;
       case ModStep:
-        PrintS("Step  ");
-        break;
+        PrintS("Step  ");
+        break;
       case ModCalc:
-        PrintS("Calc  ");
-        break;
+        PrintS("Calc  ");
+        break;
       case ModRead:
-        PrintS("Read ");
-        break;
+        PrintS("Read ");
+        break;
       case ModWrite:
-        PrintS("Write  ");
-        break;
+        PrintS("Write  ");
+        break;
       }
       PrintS("\n");

Singular/comm.h

@@ -86 +86 @@
      if(vec!=NULL)
        {
-        for(int i=0; i<nr; i++)
-          {
-            if((vec[i])!=NULL)
-              delete (vec[i]);
-            vec[i]=NULL;
-          }
+          for(int i=0; i<nr; i++)
+           {
+             if((vec[i])!=NULL)
+               delete (vec[i]);
+             vec[i]=NULL;
+           }
        }
      Free((ADDRESS)vec,sizeof(intvec*)*nr);

Singular/fglmcomb.cc

@@ -1 +1 @@
 // emacs edit mode for this file is -*- C++ -*-
-// $Id: fglmcomb.cc,v 1.12 1998-06-04 13:38:48 wichmann Exp $
+// $Id: fglmcomb.cc,v 1.13 1998-09-24 09:59:38 Singular Exp $
 
 /****************************************
@@ -192 +192 @@
 //         pSetExpV( m[k], temp->exp );
 //         pSetm( m[k] );
-        m[k]= pNew();
-        pCopy2( m[k], temp );
-        pSetCoeff( m[k], nInit(1) );
+        m[k]= pNew();
+        pCopy2( m[k], temp );
+        pSetCoeff( m[k], nInit(1) );
         pIter( temp );
     }
@@ -242 +242 @@
         int b;
         while ( temp != NULL )
-        {
+        {
             BOOLEAN found = FALSE;
             for ( b= 0; (b < basisSize) && (found == FALSE); b++ )
-            {
+            {
                 if ( pEqual( temp, basis[b] ) )
-                {
+                {
                     found= TRUE;
                 }
             }
             if ( found == FALSE )
-            {
+            {
                 if ( basisSize == basisMax )
-                {
+                {
                     // Expand the basis
                     basis= (polyset)ReAlloc( basis, basisMax * sizeof( poly ), (basisMax + basisBS ) * sizeof( poly ) );
@@ -262 +262 @@
 //                 pSetExpV( basis[basisSize], temp->exp );
 //                 pSetm( basis[basisSize] );
-                basis[basisSize]= pNew();
-                pCopy2( basis[basisSize], temp );
-                pSetCoeff( basis[basisSize], nInit(1) );
+                basis[basisSize]= pNew();
+                pCopy2( basis[basisSize], temp );
+                pSetCoeff( basis[basisSize], nInit(1) );
                 basisSize++;
             }
@@ -280 +280 @@
     for ( k= 0; k < numMonoms; k++ ) {
         STICKYPROT( "." );
- 
+
 #ifndef HAVE_EXPLICIT_CONSTR
         v[k].mac_constr_i( basisSize );
@@ -352 +352 @@
         }
 #ifndef HAVE_EXPLICIT_CONSTR
-        v[best-1].clearelems();
+        v[best-1].clearelems();
 #else
         v[best-1].~fglmVector();

Singular/fglmgauss.cc

@@ -1 +1 @@
 // emacs edit mode for this file is -*- C++ -*-
-// $Id: fglmgauss.cc,v 1.9 1998-06-04 13:39:21 wichmann Exp $
+// $Id: fglmgauss.cc,v 1.10 1998-09-24 09:59:38 Singular Exp $
 
 /****************************************
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* 
+/*
 * ABSTRACT - class gaussReducer. Used in fglmzero.cc and fglmhom.cc
 *  to find linear dependecies of fglmVectors.
@@ -27 +27 @@
     number pdenom;
     number fac;
-    gaussElem( const fglmVector newv, const fglmVector newp, number & newpdenom, number & newfac ) : v( newv ), p( newp ), pdenom( newpdenom ), fac( newfac ) 
+    gaussElem( const fglmVector newv, const fglmVector newp, number & newpdenom, number & newfac ) : v( newv ), p( newp ), pdenom( newpdenom ), fac( newfac )
     {
-        newpdenom= NULL;
-        newfac= NULL;
+        newpdenom= NULL;
+        newfac= NULL;
     }
 
@@ -42 +42 @@
     pdenom=newpdenom;
     fac=newfac;
-        newpdenom= NULL;
-        newfac= NULL;
-    }
-#endif
-
-    ~gaussElem() 
+        newpdenom= NULL;
+        newfac= NULL;
+    }
+#endif
+
+    ~gaussElem()
     {
-        nDelete( & pdenom );
-        nDelete( & fac );
+        nDelete( & pdenom );
+        nDelete( & fac );
     }
 };
 
-gaussReducer::gaussReducer( int dimen ) 
+gaussReducer::gaussReducer( int dimen )
 {
     int k;
@@ -65 +65 @@
 #endif
     isPivot= (BOOLEAN *)Alloc( (max+1)*sizeof( BOOLEAN ) );
-    for ( k= max; k > 0; k-- ) 
-            isPivot[k]= FALSE;
+    for ( k= max; k > 0; k-- )
+            isPivot[k]= FALSE;
     perm= (int *)Alloc( (max+1)*sizeof( int ) );
 }
 
-gaussReducer::~gaussReducer() 
+gaussReducer::~gaussReducer()
 {
     int k;
@@ -77 +77 @@
     delete [] elems;
 #else
-    for ( k= size; k > 0; k-- ) 
-        elems[k].~gaussElem();
+    for ( k= size; k > 0; k-- )
+        elems[k].~gaussElem();
     Free( (ADDRESS)elems, (max+1)*sizeof( gaussElem ) );
 #endif
@@ -87 +87 @@
 
 BOOLEAN
-gaussReducer::reduce( fglmVector thev ) 
+gaussReducer::reduce( fglmVector thev )
 {
     number fac1, fac2;
@@ -98 +98 @@
     number vdenom = v.clearDenom();
     if ( ! nIsOne( vdenom ) && ! nIsZero( vdenom ) ) {
-        p.setelem( p.size(), vdenom );
+        p.setelem( p.size(), vdenom );
     }
     else {
-        nDelete( & vdenom );
+        nDelete( & vdenom );
     }
     number gcd = v.gcd();
     if ( ! nIsOne( gcd ) && ! nIsZero( gcd ) ) {
-        v /= gcd;
-        number temp= nMult( pdenom, gcd );
-        nDelete( & pdenom );
-        pdenom= temp;
+        v /= gcd;
+        number temp= nMult( pdenom, gcd );
+        nDelete( & pdenom );
+        pdenom= temp;
     }
     nDelete( & gcd );
-    
+
     int k;
     for ( k= 1; k <= size; k++ ) {
-        if ( ! v.elemIsZero( perm[k] ) ) {
-            fac1= elems[k].fac;
-            fac2= nCopy( v.getconstelem( perm[k] ) );
-            v.nihilate( fac1, fac2, elems[k].v );
-            fac1= nMult( fac1, elems[k].pdenom );
-            temp= nMult( fac2, pdenom );
-            nDelete( & fac2 );
-            fac2= temp;
-            p.nihilate( fac1, fac2, elems[k].p );
-            temp= nMult( pdenom, elems[k].pdenom );
-            nDelete( & pdenom );
-            pdenom= temp;
-            
-            nDelete( & fac1 );
-            nDelete( & fac2 );
-            number gcd = v.gcd();
-            if ( ! nIsOne( gcd ) && ! nIsZero( gcd ) ) {
-                v/= gcd;
-                number temp = nMult( pdenom, gcd );
-                nDelete( & pdenom );
-                pdenom= temp;
-            }
-            nDelete( & gcd );
-            gcd= p.gcd();
-            temp= nGcd( pdenom, gcd );
-            nDelete( & gcd );
-            gcd= temp;
-            if ( ! nIsZero( gcd ) && ! nIsOne( gcd ) ) {
-                p/= gcd;
-                temp= nDiv( pdenom, gcd );
-                nDelete( & pdenom );
-                pdenom= temp;
-                nNormalize( pdenom );
-            }
-            nDelete( & gcd );
-        }
+        if ( ! v.elemIsZero( perm[k] ) ) {
+            fac1= elems[k].fac;
+            fac2= nCopy( v.getconstelem( perm[k] ) );
+            v.nihilate( fac1, fac2, elems[k].v );
+            fac1= nMult( fac1, elems[k].pdenom );
+            temp= nMult( fac2, pdenom );
+            nDelete( & fac2 );
+            fac2= temp;
+            p.nihilate( fac1, fac2, elems[k].p );
+            temp= nMult( pdenom, elems[k].pdenom );
+            nDelete( & pdenom );
+            pdenom= temp;
+
+            nDelete( & fac1 );
+            nDelete( & fac2 );
+            number gcd = v.gcd();
+            if ( ! nIsOne( gcd ) && ! nIsZero( gcd ) ) {
+                v/= gcd;
+                number temp = nMult( pdenom, gcd );
+                nDelete( & pdenom );
+                pdenom= temp;
+            }
+            nDelete( & gcd );
+            gcd= p.gcd();
+            temp= nGcd( pdenom, gcd );
+            nDelete( & gcd );
+            gcd= temp;
+            if ( ! nIsZero( gcd ) && ! nIsOne( gcd ) ) {
+                p/= gcd;
+                temp= nDiv( pdenom, gcd );
+                nDelete( & pdenom );
+                pdenom= temp;
+                nNormalize( pdenom );
+            }
+            nDelete( & gcd );
+        }
     }
     return ( v.isZero() );
 }
 
-void 
-gaussReducer::store() 
+void
+gaussReducer::store()
 {
     // fglmASSERT( size < max );
     number fac;
     // find the pivot-element in v:
-    
+
     size++;
     int k= 1;
     while ( nIsZero(v.getconstelem(k)) || isPivot[k] ) {
-        k++;
+        k++;
     }
     // fglmASSERT( k <= dimen, "Error(1) in fglmDdata::pivot-search");
@@ -171 +171 @@
     k++;
     while ( k <= max ) {
-        if ( ! nIsZero( v.getconstelem(k) ) && ! isPivot[k] ) {
-            if ( nGreater( v.getconstelem( k ), pivot ) ) {
-                pivot= v.getconstelem( k );
-                pivotcol= k;
-            }
-        }
-        k++;
+        if ( ! nIsZero( v.getconstelem(k) ) && ! isPivot[k] ) {
+            if ( nGreater( v.getconstelem( k ), pivot ) ) {
+                pivot= v.getconstelem( k );
+                pivotcol= k;
+            }
+        }
+        k++;
     }
     // fglmASSERT( ! nIsZero( pivot ), "Error(2) fglmDdata::Pivotelement ist Null" );
     isPivot[ pivotcol ]= TRUE;
     perm[size]= pivotcol;
-    
+
     pivot= nCopy( v.getconstelem( pivotcol ) );
 #ifndef HAVE_EXPLICIT_CONSTR
@@ -191 +191 @@
 }
 
-fglmVector 
-gaussReducer::getDependence() 
+fglmVector
+gaussReducer::getDependence()
 {
     nDelete( & pdenom );

Singular/fglmhom.cc

@@ -1 +1 @@
 // emacs edit mode for this file is -*- C++ -*-
-// $Id: fglmhom.cc,v 1.10 1998-06-15 14:30:06 Singular Exp $
+// $Id: fglmhom.cc,v 1.11 1998-09-24 09:59:39 Singular Exp $
 
 /****************************************
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* 
+/*
 * ABSTRACT - The FGLM-Algorithm extended for homogeneous ideals.
 *   Calculates via the hilbert-function a groebner basis.
@@ -18 +18 @@
 #include "tok.h"
 #include "structs.h"
-#include "subexpr.h"  
+#include "subexpr.h"
 #include "polys.h"
 #include "ideals.h"
@@ -62 +62 @@
     homogElem() : v(), dv(), basis(0), destbasis(0), inDest(FALSE) {}
     homogElem( poly m, int b, BOOLEAN ind ) :
-        basis(b), inDest(ind) 
+        basis(b), inDest(ind)
     {
-        mon.dm= m;
-        mon.sm= NULL;
+        mon.dm= m;
+        mon.sm= NULL;
     }
 };
 
-struct homogData 
+struct homogData
 {
     ideal sourceIdeal;
@@ -83 +83 @@
     int overall;  // nur zum testen.
     int numberofdestbasismonoms;
-//     homogData() : sourceHeads(NULL), numSourceHeads(0), monlist(NULL), 
-//      numMonoms(0), basisSize(0) {}
+//     homogData() : sourceHeads(NULL), numSourceHeads(0), monlist(NULL),
+//         numMonoms(0), basisSize(0) {}
 };
 
 int
-hfglmNextdegree( intvec * source, ideal current, int & deg ) 
+hfglmNextdegree( intvec * source, ideal current, int & deg )
 {
     int numelems;
     intvec * newhilb = hHstdSeries( current, NULL, currQuotient );
 
-    loop 
+    loop
     {
-        if ( deg < newhilb->length() ) 
-        {
-            if ( deg < source->length() )
-                numelems= (*newhilb)[deg]-(*source)[deg];
-            else
-                numelems= (*newhilb)[deg];
-        }
-        else
-        {
-            if (deg < source->length())
-                numelems= -(*source)[deg];
-            else
-            {
-                deg= 0;
-                return 0;
-            }
-        }
-        if (numelems != 0) 
-            return numelems;
-        deg++;
-    }  
+        if ( deg < newhilb->length() )
+        {
+            if ( deg < source->length() )
+                numelems= (*newhilb)[deg]-(*source)[deg];
+            else
+                numelems= (*newhilb)[deg];
+        }
+        else
+        {
+            if (deg < source->length())
+                numelems= -(*source)[deg];
+            else
+            {
+                deg= 0;
+                return 0;
+            }
+        }
+        if (numelems != 0)
+            return numelems;
+        deg++;
+    }
     delete newhilb;
 }
 
-void 
+void
 generateMonoms( poly m, int var, int deg, homogData * dat )
 {
     if ( var == pVariables ) {
-        BOOLEAN inSource = FALSE;
-        BOOLEAN inDest = FALSE;
-        poly mon = pCopy( m );
-        pSetExp( mon, var, deg );
-        pSetm( mon );
-        ++dat->overall;
-        int i;
-        for ( i= dat->numSourceHeads - 1; (i >= 0) && (inSource==FALSE); i-- ) {
-            if ( pDivisibleBy( dat->sourceHeads[i].dm, mon ) ) {
-                inSource= TRUE;
-            }
-        }
-        for ( i= dat->numDestPolys - 1; (i >= 0) && (inDest==FALSE); i-- ) {
-            if ( pDivisibleBy( (dat->destIdeal->m)[i], mon ) ) {
-                inDest= TRUE;
-            }
-        }
-        if ( (!inSource) || (!inDest) ) {
-            int basis = 0;
-            if ( !inSource )
-                basis= ++(dat->basisSize);
-            if ( !inDest ) 
-                ++dat->numberofdestbasismonoms;
-            if ( dat->numMonoms == dat->monlistmax ) {
-                dat->monlist= (homogElem * )ReAlloc( dat->monlist, (dat->monlistmax)*sizeof( homogElem ), (dat->monlistmax+dat->monlistblock) * sizeof( homogElem ) );
-                int k;
-                for ( k= dat->monlistmax; k < (dat->monlistmax+dat->monlistblock); k++ ) 
-                    dat->monlist[k].homogElem();
-                dat->monlistmax+= dat->monlistblock;
-            }
-            dat->monlist[dat->numMonoms]= homogElem( mon, basis, inDest );
-            dat->numMonoms++;
-            if ( inSource && ! inDest ) PROT( "\\" );
-            if ( ! inSource && inDest ) PROT( "/" );
-            if ( ! inSource && ! inDest ) PROT( "." );
-        }
-        else {
-            pDelete( & mon );
-        }
-        return;
+        BOOLEAN inSource = FALSE;
+        BOOLEAN inDest = FALSE;
+        poly mon = pCopy( m );
+        pSetExp( mon, var, deg );
+        pSetm( mon );
+        ++dat->overall;
+        int i;
+        for ( i= dat->numSourceHeads - 1; (i >= 0) && (inSource==FALSE); i-- ) {
+            if ( pDivisibleBy( dat->sourceHeads[i].dm, mon ) ) {
+                inSource= TRUE;
+            }
+        }
+        for ( i= dat->numDestPolys - 1; (i >= 0) && (inDest==FALSE); i-- ) {
+            if ( pDivisibleBy( (dat->destIdeal->m)[i], mon ) ) {
+                inDest= TRUE;
+            }
+        }
+        if ( (!inSource) || (!inDest) ) {
+            int basis = 0;
+            if ( !inSource )
+                basis= ++(dat->basisSize);
+            if ( !inDest )
+                ++dat->numberofdestbasismonoms;
+            if ( dat->numMonoms == dat->monlistmax ) {
+                dat->monlist= (homogElem * )ReAlloc( dat->monlist, (dat->monlistmax)*sizeof( homogElem ), (dat->monlistmax+dat->monlistblock) * sizeof( homogElem ) );
+                int k;
+                for ( k= dat->monlistmax; k < (dat->monlistmax+dat->monlistblock); k++ )
+                    dat->monlist[k].homogElem();
+                dat->monlistmax+= dat->monlistblock;
+            }
+            dat->monlist[dat->numMonoms]= homogElem( mon, basis, inDest );
+            dat->numMonoms++;
+            if ( inSource && ! inDest ) PROT( "\\" );
+            if ( ! inSource && inDest ) PROT( "/" );
+            if ( ! inSource && ! inDest ) PROT( "." );
+        }
+        else {
+            pDelete( & mon );
+        }
+        return;
     }
     else {
-        poly newm = pCopy( m );
-        while ( deg >= 0 ) {
-            generateMonoms( newm, var+1, deg, dat );
-            pIncrExp( newm, var );
-            pSetm( newm );
-            deg--;
-        }
-        pDelete( & newm );
+        poly newm = pCopy( m );
+        while ( deg >= 0 ) {
+            generateMonoms( newm, var+1, deg, dat );
+            pIncrExp( newm, var );
+            pSetm( newm );
+            deg--;
+        }
+        pDelete( & newm );
     }
     return;
@@ -178 +178 @@
 
 void
-mapMonoms( ring oldRing, homogData & dat ) 
+mapMonoms( ring oldRing, homogData & dat )
 {
     int * vperm = (int *)Alloc( (currRing->N + 1)*sizeof(int) );
@@ -185 +185 @@
     int s;
     for ( s= dat.numMonoms - 1; s >= 0; s-- ) {
-//      dat.monlist[s].mon.sm= pPermPoly( dat.monlist[s].mon.dm, vperm, currRing->N, NULL, 0 );
+//        dat.monlist[s].mon.sm= pPermPoly( dat.monlist[s].mon.dm, vperm, currRing->N, NULL, 0 );
       // obachman: changed the folowing to reflect the new calling interface of
       // pPermPoly -- Tim please check whether this is correct!
-        dat.monlist[s].mon.sm= pPermPoly( dat.monlist[s].mon.dm, vperm, oldRing, NULL, 0 );      
+        dat.monlist[s].mon.sm= pPermPoly( dat.monlist[s].mon.dm, vperm, oldRing, NULL, 0 );
     }
 }
 
 void
-getVectorRep( homogData & dat ) 
+getVectorRep( homogData & dat )
 {
     // Calculate the NormalForms
     int s;
     for ( s= 0;  s < dat.numMonoms; s++ ) {
-        if ( dat.monlist[s].inDest == FALSE ) {
-            fglmVector v;
-            if ( dat.monlist[s].basis == 0 ) {
-                v= fglmVector( dat.basisSize );
-                // now the monom is in L(source)
-                PROT( "(" );
-                poly nf = kNF( dat.sourceIdeal, NULL, dat.monlist[s].mon.sm );
-                PROT( ")" );
-                poly temp = nf;
-                while (temp != NULL ) {
-                    int t;
-                    for ( t= dat.numMonoms - 1; t >= 0; t-- ) {
-                        if ( dat.monlist[t].basis > 0 ) {
-                            if ( pEqual( dat.monlist[t].mon.sm, temp ) ) {
-                                number coeff= nCopy( pGetCoeff( temp ) );
-                                v.setelem( dat.monlist[t].basis, coeff );
-                            }
-                        }
-                    }
-                    pIter(temp);
-                }
-                pDelete( & nf );
-            }
-            else {
-                PROT( "." );
-                v= fglmVector( dat.basisSize, dat.monlist[s].basis );
-            }
-            dat.monlist[s].v= v;
-        }
+        if ( dat.monlist[s].inDest == FALSE ) {
+            fglmVector v;
+            if ( dat.monlist[s].basis == 0 ) {
+                v= fglmVector( dat.basisSize );
+                // now the monom is in L(source)
+                PROT( "(" );
+                poly nf = kNF( dat.sourceIdeal, NULL, dat.monlist[s].mon.sm );
+                PROT( ")" );
+                poly temp = nf;
+                while (temp != NULL ) {
+                    int t;
+                    for ( t= dat.numMonoms - 1; t >= 0; t-- ) {
+                        if ( dat.monlist[t].basis > 0 ) {
+                            if ( pEqual( dat.monlist[t].mon.sm, temp ) ) {
+                                number coeff= nCopy( pGetCoeff( temp ) );
+                                v.setelem( dat.monlist[t].basis, coeff );
+                            }
+                        }
+                    }
+                    pIter(temp);
+                }
+                pDelete( & nf );
+            }
+            else {
+                PROT( "." );
+                v= fglmVector( dat.basisSize, dat.monlist[s].basis );
+            }
+            dat.monlist[s].v= v;
+        }
     }
 }
 
 void
-remapVectors( ring oldring, homogData & dat ) 
+remapVectors( ring oldring, homogData & dat )
 {
     nSetMap( oldring->ch, oldring->parameter, oldring->P, oldring->minpoly );
     int s;
     for ( s= dat.numMonoms - 1; s >= 0; s-- ) {
-        if ( dat.monlist[s].inDest == FALSE ) {
-            int k;
-            fglmVector newv( dat.basisSize );
-            for ( k= dat.basisSize; k > 0; k-- ){
-                number newnum= nMap( dat.monlist[s].v.getelem( k ) );
-                newv.setelem( k, newnum );
-            }
-            dat.monlist[s].dv= newv;
-        }
+        if ( dat.monlist[s].inDest == FALSE ) {
+            int k;
+            fglmVector newv( dat.basisSize );
+            for ( k= dat.basisSize; k > 0; k-- ){
+                number newnum= nMap( dat.monlist[s].v.getelem( k ) );
+                newv.setelem( k, newnum );
+            }
+            dat.monlist[s].dv= newv;
+        }
     }
 }
 
 void
-gaussreduce( homogData & dat, int maxnum, int BS ) 
+gaussreduce( homogData & dat, int maxnum, int BS )
 {
     int s;
@@ -256 +256 @@
     int destbasisSize = 0;
     gaussReducer gauss( dat.basisSize );
-    
+
     for ( s= 0; (s < dat.numMonoms) && (found < maxnum); s++ ) {
-        if ( dat.monlist[s].inDest == FALSE ) {
-            if ( gauss.reduce( dat.monlist[s].dv ) == FALSE ) {
-                destbasisSize++;
-                dat.monlist[s].destbasis= destbasisSize;
-                gauss.store();
-                PROT( "." );
-            }
-            else {
-                fglmVector p= gauss.getDependence();
-                poly result = pCopy( dat.monlist[s].mon.dm );
-                pSetCoeff( result, nCopy( p.getconstelem( p.size() ) ) );
-                int l = 0;
-                int k;
-                for ( k= 1; k < p.size(); k++ ) {
-                    if ( ! p.elemIsZero( k ) ) {
-                        while ( dat.monlist[l].destbasis != k ) 
-                            l++;
-                        poly temp = pCopy( dat.monlist[l].mon.dm );
-                        pSetCoeff( temp, nCopy( p.getconstelem( k ) ) );
-                        result= pAdd( result, temp );
-                    }
-                }
-                if ( ! nGreaterZero( pGetCoeff( result ) ) ) result= pNeg( result );
-//              PROT2( "(%s)", pString( result ) );
-                PROT( "+" );
-                found++;
-                (dat.destIdeal->m)[dat.numDestPolys]= result;
-                dat.numDestPolys++;
-                if ( IDELEMS(dat.destIdeal) == dat.numDestPolys ) {
-                    pEnlargeSet( & dat.destIdeal->m, IDELEMS( dat.destIdeal ), BS );
-                    IDELEMS( dat.destIdeal )+= BS;
-                }
-                
-            }
-                
-        }
+        if ( dat.monlist[s].inDest == FALSE ) {
+            if ( gauss.reduce( dat.monlist[s].dv ) == FALSE ) {
+                destbasisSize++;
+                dat.monlist[s].destbasis= destbasisSize;
+                gauss.store();
+                PROT( "." );
+            }
+            else {
+                fglmVector p= gauss.getDependence();
+                poly result = pCopy( dat.monlist[s].mon.dm );
+                pSetCoeff( result, nCopy( p.getconstelem( p.size() ) ) );
+                int l = 0;
+                int k;
+                for ( k= 1; k < p.size(); k++ ) {
+                    if ( ! p.elemIsZero( k ) ) {
+                        while ( dat.monlist[l].destbasis != k )
+                            l++;
+                        poly temp = pCopy( dat.monlist[l].mon.dm );
+                        pSetCoeff( temp, nCopy( p.getconstelem( k ) ) );
+                        result= pAdd( result, temp );
+                    }
+                }
+                if ( ! nGreaterZero( pGetCoeff( result ) ) ) result= pNeg( result );
+//                PROT2( "(%s)", pString( result ) );
+                PROT( "+" );
+                found++;
+                (dat.destIdeal->m)[dat.numDestPolys]= result;
+                dat.numDestPolys++;
+                if ( IDELEMS(dat.destIdeal) == dat.numDestPolys ) {
+                    pEnlargeSet( & dat.destIdeal->m, IDELEMS( dat.destIdeal ), BS );
+                    IDELEMS( dat.destIdeal )+= BS;
+                }
+
+            }
+
+        }
     }
     PROT2( "(%i", s );
@@ -313 +313 @@
     ring sourceRing = currRing;
 
-    intvec * hilb = hHstdSeries( sourceIdeal, NULL, currQuotient ); 
+    intvec * hilb = hHstdSeries( sourceIdeal, NULL, currQuotient );
     int s;
     dat.sourceIdeal= sourceIdeal;
     dat.sourceHeads= (doublepoly *)Alloc( IDELEMS( sourceIdeal ) * sizeof( doublepoly ) );
     for ( s= IDELEMS( sourceIdeal ) - 1; s >= 0; s-- ) {
-        dat.sourceHeads[s].sm= pHead( (sourceIdeal->m)[s] );
+        dat.sourceHeads[s].sm= pHead( (sourceIdeal->m)[s] );
     }
     dat.numSourceHeads= IDELEMS( sourceIdeal );
@@ -329 +329 @@
     nSetMap( sourceRing->ch, sourceRing->parameter, sourceRing->P, sourceRing->minpoly );
     for ( s= IDELEMS( sourceIdeal ) - 1; s >= 0; s-- ) {
-        dat.sourceHeads[s].dm= pPermPoly( dat.sourceHeads[s].sm, vperm, sourceRing, NULL, 0 );
+        dat.sourceHeads[s].dm= pPermPoly( dat.sourceHeads[s].sm, vperm, sourceRing, NULL, 0 );
     }
 
@@ -336 +336 @@
 
     while ( (numGBelems= hfglmNextdegree( hilb, dat.destIdeal, deg )) != 0 ) {
-        int num = 0;  // the number of monoms of degree deg
-        PROT2( "deg= %i ", deg );
-        PROT2( "num= %i\ngen>", numGBelems );
-        dat.monlistblock= 512;
-        dat.monlistmax= dat.monlistblock;
-        dat.monlist= (homogElem *)Alloc( dat.monlistmax*sizeof( homogElem ) );
-        int j;
-        for ( j= dat.monlistmax - 1; j >= 0; j-- ) dat.monlist[j].homogElem();
-        dat.numMonoms= 0;
-        dat.basisSize= 0;
-        dat.overall= 0;
-        dat.numberofdestbasismonoms= 0;
-        
-        poly start= pOne();
-        generateMonoms( start, 1, deg, &dat );
-        pDelete( & start );
-
-        PROT2( "(%i/", dat.basisSize );
-        PROT2( "%i)\nvec>", dat.overall );
-        // switch to sourceRing and map monoms
-        rSetHdl( sourceRingHdl, TRUE );
-        mapMonoms( destRing, dat );
-        getVectorRep( dat );
-        
-        // switch to destination Ring and remap the vectors
-        rSetHdl( destRingHdl, TRUE );
-        remapVectors( sourceRing, dat );
-        
-        PROT( "<\nred>" );
-        // now do gaussian reduction
-        gaussreduce( dat, numGBelems, groebnerBS );
-
-        Free( (ADDRESS)dat.monlist, dat.monlistmax*sizeof( homogElem ) );
-        PROT( "<\n" );
+        int num = 0;  // the number of monoms of degree deg
+        PROT2( "deg= %i ", deg );
+        PROT2( "num= %i\ngen>", numGBelems );
+        dat.monlistblock= 512;
+        dat.monlistmax= dat.monlistblock;
+        dat.monlist= (homogElem *)Alloc( dat.monlistmax*sizeof( homogElem ) );
+        int j;
+        for ( j= dat.monlistmax - 1; j >= 0; j-- ) dat.monlist[j].homogElem();
+        dat.numMonoms= 0;
+        dat.basisSize= 0;
+        dat.overall= 0;
+        dat.numberofdestbasismonoms= 0;
+
+        poly start= pOne();
+        generateMonoms( start, 1, deg, &dat );
+        pDelete( & start );
+
+        PROT2( "(%i/", dat.basisSize );
+        PROT2( "%i)\nvec>", dat.overall );
+        // switch to sourceRing and map monoms
+        rSetHdl( sourceRingHdl, TRUE );
+        mapMonoms( destRing, dat );
+        getVectorRep( dat );
+
+        // switch to destination Ring and remap the vectors
+        rSetHdl( destRingHdl, TRUE );
+        remapVectors( sourceRing, dat );
+
+        PROT( "<\nred>" );
+        // now do gaussian reduction
+        gaussreduce( dat, numGBelems, groebnerBS );
+
+        Free( (ADDRESS)dat.monlist, dat.monlistmax*sizeof( homogElem ) );
+        PROT( "<\n" );
     }
     PROT( "\n" );

Singular/fglmvec.cc

@@ -1 +1 @@
 // emacs edit mode for this file is -*- C++ -*-
-// $Id: fglmvec.cc,v 1.10 1998-06-04 13:39:14 wichmann Exp $
+// $Id: fglmvec.cc,v 1.11 1998-09-24 09:59:40 Singular Exp $
 
 /****************************************
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* 
+/*
 * ABSTRACT - The FGLM-Algorithm
 *   Implementation of number-vectors for the fglm algorithm.
 *   (See fglm.cc). Based on a letter-envelope implementation, mainly
-*   written to be used by the fglm algorithm. Hence they are 
+*   written to be used by the fglm algorithm. Hence they are
 *   specialized for this purpose.
 */
@@ -17 +17 @@
 #ifdef HAVE_FGLM
 #include "mmemory.h"
-#include "tok.h" 
+#include "tok.h"
 #include "structs.h"
 #include "numbers.h"
@@ -38 +38 @@
     fglmVectorRep() : ref_count(1), N(0), elems(0) {}
     fglmVectorRep( int n, number * e ) : ref_count(1), N(n), elems(e) {}
-    fglmVectorRep( int n ) : ref_count(1), N(n) 
-    {
-        fglmASSERT( N >= 0, "illegal Vector representation" );
-        if ( N == 0 ) 
-            elems= 0;
-        else {
-            elems= (number *)Alloc( N*sizeof( number ) );
-            for ( int i= N-1; i >= 0; i-- )
-                elems[i]= nInit( 0 );
-        }
+    fglmVectorRep( int n ) : ref_count(1), N(n)
+    {
+        fglmASSERT( N >= 0, "illegal Vector representation" );
+        if ( N == 0 )
+            elems= 0;
+        else {
+            elems= (number *)Alloc( N*sizeof( number ) );
+            for ( int i= N-1; i >= 0; i-- )
+                elems[i]= nInit( 0 );
+        }
     }
     ~fglmVectorRep()
     {
-        if ( N > 0 ) {
-            for ( int i= N-1; i >= 0; i-- )
-                nDelete( elems + i );
-            Free( (ADDRESS)elems, N*sizeof( number ) );
-        }
+        if ( N > 0 ) {
+            for ( int i= N-1; i >= 0; i-- )
+                nDelete( elems + i );
+            Free( (ADDRESS)elems, N*sizeof( number ) );
+        }
     }
 
     fglmVectorRep* clone() const
     {
-        if ( N > 0 ) {
-            number * elems_clone;
-            elems_clone= (number *)Alloc( N*sizeof( number ) );
-            for ( int i= N-1; i >= 0; i-- )
-                elems_clone[i] = nCopy( elems[i] );
-            return new fglmVectorRep( N, elems_clone );
-        } else
-            return new fglmVectorRep( N, 0 );
+        if ( N > 0 ) {
+            number * elems_clone;
+            elems_clone= (number *)Alloc( N*sizeof( number ) );
+            for ( int i= N-1; i >= 0; i-- )
+                elems_clone[i] = nCopy( elems[i] );
+            return new fglmVectorRep( N, elems_clone );
+        } else
+            return new fglmVectorRep( N, 0 );
     }
     BOOLEAN deleteObject() { return --ref_count == 0; }
@@ -75 +75 @@
 
     int size() const { return N; }
-    int isZero() const 
-    {
-        int k;
-        for ( k= N; k > 0; k-- )
-            if ( ! nIsZero( getconstelem( k ) ) )
-                return 0;
-        return 1;
-    }
-    int numNonZeroElems() const 
-    {
-        int num = 0;
-        int k;
-        for ( k= N; k > 0; k-- )
-            if ( ! nIsZero( getconstelem( k ) ) ) num++;
-        return num;
+    int isZero() const
+    {
+        int k;
+        for ( k= N; k > 0; k-- )
+            if ( ! nIsZero( getconstelem( k ) ) )
+                return 0;
+        return 1;
+    }
+    int numNonZeroElems() const
+    {
+        int num = 0;
+        int k;
+        for ( k= N; k > 0; k-- )
+            if ( ! nIsZero( getconstelem( k ) ) ) num++;
+        return num;
     }
     void setelem( int i, number n )
     {
-        fglmASSERT( 0 < i && i <= N, "setelem: wrong index" );
-        nDelete( elems + i-1 );
-        elems[i-1]= n;
-    }
-    number ejectelem( int i, number n ) 
-    {
-        fglmASSERT( isUnique(), "should only be called if unique!" );
-        number temp= elems[i-1];
-        elems[i-1]= n;
-        return temp;
+        fglmASSERT( 0 < i && i <= N, "setelem: wrong index" );
+        nDelete( elems + i-1 );
+        elems[i-1]= n;
+    }
+    number ejectelem( int i, number n )
+    {
+        fglmASSERT( isUnique(), "should only be called if unique!" );
+        number temp= elems[i-1];
+        elems[i-1]= n;
+        return temp;
     }
     number & getelem( int i )
     {
-        fglmASSERT( 0 < i && i <= N, "getelem: wrong index" );
-        return elems[i-1];
+        fglmASSERT( 0 < i && i <= N, "getelem: wrong index" );
+        return elems[i-1];
     }
     const number getconstelem( int i) const
     {
-        fglmASSERT( 0 < i && i <= N, "getconstelem: wrong index" );
-        return elems[i-1];
+        fglmASSERT( 0 < i && i <= N, "getconstelem: wrong index" );
+        return elems[i-1];
     }
     friend class fglmVector;
@@ -141 +141 @@
 {
     if ( rep->deleteObject() )
-        delete rep;
+        delete rep;
 }
 
@@ -158 +158 @@
 
 void
-fglmVector::clearelems() 
+fglmVector::clearelems()
 {
     if ( rep->deleteObject() )
@@ -165 +165 @@
 #endif
 
-void 
+void
 fglmVector::makeUnique()
 {
     if ( rep->refcount() != 1 ) {
-        rep->deleteObject();
-        rep= rep->clone();
-    }
-}
-
-int 
+        rep->deleteObject();
+        rep= rep->clone();
+    }
+}
+
+int
 fglmVector::size() const
 {
@@ -187 +187 @@
 
 void
-fglmVector::nihilate( const number fac1, const number fac2, const fglmVector v ) 
+fglmVector::nihilate( const number fac1, const number fac2, const fglmVector v )
 {
     int i;
@@ -194 +194 @@
     fglmASSERT( vsize <= rep->size(), "v has to be smaller oder equal" );
     if ( rep->isUnique() ) {
-        for ( i= vsize; i > 0; i-- ) {
-            term1= nMult( fac1, rep->getconstelem( i ) );
-            term2= nMult( fac2, v.rep->getconstelem( i ) );
-            rep->setelem( i, nSub( term1, term2 ) );
-            nDelete( &term1 );
-            nDelete( &term2 );
-        }
-        for ( i= rep->size(); i > vsize; i-- ) {
-            rep->setelem( i, nMult( fac1, rep->getconstelem( i ) ) );
-        }
-    }
-    else 
-    {
-        number* newelems;
-        newelems= (number *)Alloc( rep->size()*sizeof( number ) );
-        for ( i= vsize; i > 0; i-- ) {
-            term1= nMult( fac1, rep->getconstelem( i ) );
-            term2= nMult( fac2, v.rep->getconstelem( i ) );
-            newelems[i-1]= nSub( term1, term2 );
-            nDelete( &term1 );
-            nDelete( &term2 );
-        }
-        for ( i= rep->size(); i > vsize; i-- ) {
-            newelems[i-1]= nMult( fac1, rep->getconstelem( i ) );
-        }
-        rep->deleteObject();
-        rep= new fglmVectorRep( rep->size(), newelems );
-    }
-}
-
-fglmVector & 
+        for ( i= vsize; i > 0; i-- ) {
+            term1= nMult( fac1, rep->getconstelem( i ) );
+            term2= nMult( fac2, v.rep->getconstelem( i ) );
+            rep->setelem( i, nSub( term1, term2 ) );
+            nDelete( &term1 );
+            nDelete( &term2 );
+        }
+        for ( i= rep->size(); i > vsize; i-- ) {
+            rep->setelem( i, nMult( fac1, rep->getconstelem( i ) ) );
+        }
+    }
+    else
+    {
+        number* newelems;
+        newelems= (number *)Alloc( rep->size()*sizeof( number ) );
+        for ( i= vsize; i > 0; i-- ) {
+            term1= nMult( fac1, rep->getconstelem( i ) );
+            term2= nMult( fac2, v.rep->getconstelem( i ) );
+            newelems[i-1]= nSub( term1, term2 );
+            nDelete( &term1 );
+            nDelete( &term2 );
+        }
+        for ( i= rep->size(); i > vsize; i-- ) {
+            newelems[i-1]= nMult( fac1, rep->getconstelem( i ) );
+        }
+        rep->deleteObject();
+        rep= new fglmVectorRep( rep->size(), newelems );
+    }
+}
+
+fglmVector &
 fglmVector::operator = ( const fglmVector & v )
 {
     if ( this != &v ) {
-        if ( rep->deleteObject() )
-            delete rep;
-        rep = v.rep->copyObject();
+        if ( rep->deleteObject() )
+            delete rep;
+        rep = v.rep->copyObject();
     }
     return *this;
@@ -239 +239 @@
 {
     if ( rep->size() == v.rep->size() ) {
-        if ( rep == v.rep ) return 1;
-        else {
-            int i;
-            for ( i= rep->size(); i > 0; i-- )
-                if ( ! nEqual( rep->getconstelem( i ), v.rep->getconstelem( i ) ) )
-                    return 0;
-            return 1;
-        }
+        if ( rep == v.rep ) return 1;
+        else {
+            int i;
+            for ( i= rep->size(); i > 0; i-- )
+                if ( ! nEqual( rep->getconstelem( i ), v.rep->getconstelem( i ) ) )
+                    return 0;
+            return 1;
+        }
     }
     return 0;
@@ -257 +257 @@
 }
 
-int 
+int
 fglmVector::isZero()
 {
@@ -263 +263 @@
 }
 
-int 
+int
 fglmVector::elemIsZero( int i )
 {
@@ -276 +276 @@
     int i;
     if ( rep->isUnique() ) {
-        for ( i= rep->size(); i > 0; i-- ) 
-            rep->setelem( i, nAdd( rep->getconstelem( i ), v.rep->getconstelem( i ) ) );
-    }
-    else 
-    {
-        int n = rep->size();
-        number* newelems;
-        newelems= (number *)Alloc( n*sizeof( number ) );
-        for ( i= n; i > 0; i-- )
-            newelems[i-1]= nAdd( rep->getconstelem( i ), v.rep->getconstelem( i ) );
-        rep->deleteObject();
-        rep= new fglmVectorRep( n, newelems );
+        for ( i= rep->size(); i > 0; i-- )
+            rep->setelem( i, nAdd( rep->getconstelem( i ), v.rep->getconstelem( i ) ) );
+    }
+    else
+    {
+        int n = rep->size();
+        number* newelems;
+        newelems= (number *)Alloc( n*sizeof( number ) );
+        for ( i= n; i > 0; i-- )
+            newelems[i-1]= nAdd( rep->getconstelem( i ), v.rep->getconstelem( i ) );
+        rep->deleteObject();
+        rep= new fglmVectorRep( n, newelems );
     }
     return *this;
@@ -298 +298 @@
     int i;
     if ( rep->isUnique() ) {
-        for ( i= rep->size(); i > 0; i-- ) 
-            rep->setelem( i, nSub( rep->getconstelem( i ), v.rep->getconstelem( i ) ) );
-    }
-    else 
-    {
-        int n = rep->size();
-        number* newelems;
-        newelems= (number *)Alloc( n*sizeof( number ) );
-        for ( i= n; i > 0; i-- )
-            newelems[i-1]= nSub( rep->getconstelem( i ), v.rep->getconstelem( i ) );
-        rep->deleteObject();
-        rep= new fglmVectorRep( n, newelems );
+        for ( i= rep->size(); i > 0; i-- )
+            rep->setelem( i, nSub( rep->getconstelem( i ), v.rep->getconstelem( i ) ) );
+    }
+    else
+    {
+        int n = rep->size();
+        number* newelems;
+        newelems= (number *)Alloc( n*sizeof( number ) );
+        for ( i= n; i > 0; i-- )
+            newelems[i-1]= nSub( rep->getconstelem( i ), v.rep->getconstelem( i ) );
+        rep->deleteObject();
+        rep= new fglmVectorRep( n, newelems );
     }
     return *this;
@@ -320 +320 @@
     int i;
     if ( ! rep->isUnique() ) {
-        number * temp;
-        temp= (number *)Alloc( s*sizeof( number ) );
-        for ( i= s; i > 0; i-- ) 
-            temp[i-1]= nMult( rep->getconstelem( i ), n );
-        rep->deleteObject();
-        rep= new fglmVectorRep( s, temp );
-    }
-    else 
-    {
-        for (i= s; i > 0; i-- ) 
-            rep->setelem( i, nMult( rep->getconstelem( i ), n ) );
+        number * temp;
+        temp= (number *)Alloc( s*sizeof( number ) );
+        for ( i= s; i > 0; i-- )
+            temp[i-1]= nMult( rep->getconstelem( i ), n );
+        rep->deleteObject();
+        rep= new fglmVectorRep( s, temp );
+    }
+    else
+    {
+        for (i= s; i > 0; i-- )
+            rep->setelem( i, nMult( rep->getconstelem( i ), n ) );
     }
     return *this;
@@ -341 +341 @@
     int i;
     if ( ! rep->isUnique() ) {
-        number * temp;
-        temp= (number *)Alloc( s*sizeof( number ) );
-        for ( i= s; i > 0; i-- ) {
-            temp[i-1]= nDiv( rep->getconstelem( i ), n );
-            nNormalize( temp[i-1] );
-        }
-        rep->deleteObject();
-        rep= new fglmVectorRep( s, temp );
-    }
-    else 
-    {
-        for (i= s; i > 0; i-- ) {
-            rep->setelem( i, nDiv( rep->getconstelem( i ), n ) );
-            nNormalize( rep->getelem( i ) );
-        }
+        number * temp;
+        temp= (number *)Alloc( s*sizeof( number ) );
+        for ( i= s; i > 0; i-- ) {
+            temp[i-1]= nDiv( rep->getconstelem( i ), n );
+            nNormalize( temp[i-1] );
+        }
+        rep->deleteObject();
+        rep= new fglmVectorRep( s, temp );
+    }
+    else
+    {
+        for (i= s; i > 0; i-- ) {
+            rep->setelem( i, nDiv( rep->getconstelem( i ), n ) );
+            nNormalize( rep->getelem( i ) );
+        }
     }
     return *this;
 }
 
-fglmVector 
-operator - ( const fglmVector & v ) 
+fglmVector
+operator - ( const fglmVector & v )
 {
     fglmVector temp( v.size() );
@@ -367 +367 @@
     number n ;
     for ( i= v.size(); i > 0; i-- ) {
-        n= nCopy( v.getconstelem( i ) );
-        n= nNeg( n );
-        temp.setelem( i, n );
+        n= nCopy( v.getconstelem( i ) );
+        n= nNeg( n );
+        temp.setelem( i, n );
     }
     return temp;
 }
 
-fglmVector 
-operator + ( const fglmVector & lhs, const fglmVector & rhs ) 
+fglmVector
+operator + ( const fglmVector & lhs, const fglmVector & rhs )
 {
     fglmVector temp= lhs;
@@ -382 +382 @@
 }
 
-fglmVector 
+fglmVector
 operator - ( const fglmVector & lhs, const fglmVector & rhs )
 {
@@ -390 +390 @@
 }
 
-fglmVector 
+fglmVector
 operator * ( const fglmVector & v, const number n )
 {
@@ -413 +413 @@
 }
 
-const number 
+const number
 fglmVector::getconstelem( int i ) const
 {
@@ -427 +427 @@
 }
 
-number 
+number
 fglmVector::gcd() const
-{ 
+{
     int i= rep->size();
     BOOLEAN found = FALSE;
@@ -436 +436 @@
     number current;
     while( i > 0 && ! found ) {
-        current= rep->getconstelem( i );
-        if ( ! nIsZero( current ) ) {
-            theGcd= nCopy( current );
-            found= TRUE;
-            if ( ! nGreaterZero( theGcd ) ) {
-                theGcd= nNeg( theGcd );
-            }
-            if ( nIsOne( theGcd ) ) gcdIsOne= TRUE;
-        }
-        i--;
+        current= rep->getconstelem( i );
+        if ( ! nIsZero( current ) ) {
+            theGcd= nCopy( current );
+            found= TRUE;
+            if ( ! nGreaterZero( theGcd ) ) {
+                theGcd= nNeg( theGcd );
+            }
+            if ( nIsOne( theGcd ) ) gcdIsOne= TRUE;
+        }
+        i--;
     }
     if ( found ) {
-        while ( i > 0 && ! gcdIsOne ) {
-            current= rep->getconstelem( i );
-            if ( ! nIsZero( current ) ) {
-                number temp= nGcd( theGcd, current );
-                nDelete( &theGcd );
-                theGcd= temp;
-                if ( nIsOne( theGcd ) ) gcdIsOne= TRUE;
-            }
-            i--;
-        }
-    }
-    else 
-        theGcd= nInit( 0 );
+        while ( i > 0 && ! gcdIsOne ) {
+            current= rep->getconstelem( i );
+            if ( ! nIsZero( current ) ) {
+                number temp= nGcd( theGcd, current );
+                nDelete( &theGcd );
+                theGcd= temp;
+                if ( nIsOne( theGcd ) ) gcdIsOne= TRUE;
+            }
+            i--;
+        }
+    }
+    else
+        theGcd= nInit( 0 );
     return theGcd;
 }
 
 number
-fglmVector::clearDenom() 
+fglmVector::clearDenom()
 {
     number theLcm = nInit( 1 );
@@ -472 +472 @@
     int i;
     for ( i= size(); i > 0; i-- ) {
-        if ( ! nIsZero( rep->getconstelem(i) ) ) {
-            isZero= FALSE;
-            number temp= nLcm( theLcm, rep->getconstelem( i ) );
-            nDelete( &theLcm );
-            theLcm= temp;
-        }
+        if ( ! nIsZero( rep->getconstelem(i) ) ) {
+            isZero= FALSE;
+            number temp= nLcm( theLcm, rep->getconstelem( i ) );
+            nDelete( &theLcm );
+            theLcm= temp;
+        }
     }
     if ( isZero ) {
-        nDelete( &theLcm );
-        theLcm= nInit( 0 );
+        nDelete( &theLcm );
+        theLcm= nInit( 0 );
     }
     else {
-        if ( ! nIsOne( theLcm ) ) {
-            *this *= theLcm;
-            for ( i= size(); i > 0; i-- ) {
-                nNormalize( rep->getelem( i ) );
-            }
-        }
+        if ( ! nIsOne( theLcm ) ) {
+            *this *= theLcm;
+            for ( i= size(); i > 0; i-- ) {
+                nNormalize( rep->getelem( i ) );
+            }
+        }
     }
     return theLcm;

Singular/fglmzero.cc

@@ -1 +1 @@
 // emacs edit mode for this file is -*- C++ -*-
-// $Id: fglmzero.cc,v 1.17 1998-06-03 15:25:20 obachman Exp $
+// $Id: fglmzero.cc,v 1.18 1998-09-24 09:59:40 Singular Exp $
 
 /****************************************
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* 
+/*
 * ABSTRACT - The FGLM-Algorithm
 *   Implementation of the fglm algorithm for 0-dimensional ideals,
 *   based on an idea by Faugere/Gianni/Lazard and Mora.
-*   The procedure CalculateFunctionals calculates the functionals 
+*   The procedure CalculateFunctionals calculates the functionals
 *   which define the given ideal in the source ring. They build the
 *   input for GroebnerViaFunctionals, which defines the reduced
@@ -35 +35 @@
 #include "fglmgauss.h"
 // assumes, that NOSTREAMIO is set in factoryconf.h, which is included
-// by templates/list.h. 
+// by templates/list.h.
 #include <templates/ftmpl_list.h>
 #define PROT(msg)
@@ -46 +46 @@
 // internal Version: 1.3.1.12
 // ============================================================
-//!      The idealFunctionals 
+//!      The idealFunctionals
 // ============================================================
 
@@ -71 +71 @@
     int * currentSize;
     matHeader ** func;
-    matHeader * grow( int var );  
+    matHeader * grow( int var );
 public:
     idealFunctionals( int blockSize, int numFuncs );
     ~idealFunctionals();
 
-    int dimen() const { fglmASSERT( _size>0, "called to early"); return _size; } 
+    int dimen() const { fglmASSERT( _size>0, "called to early"); return _size; }
     void endofConstruction();
     void map( ring source );
@@ -85 +85 @@
 };
 
-idealFunctionals::idealFunctionals( int blockSize, int numFuncs ) 
+idealFunctionals::idealFunctionals( int blockSize, int numFuncs )
 {
     int k;
@@ -94 +94 @@
 
     currentSize= (int *)Alloc( _nfunc*sizeof( int ) );
-    for ( k= _nfunc-1; k >= 0; k-- ) 
-        currentSize[k]= 0;
+    for ( k= _nfunc-1; k >= 0; k-- )
+        currentSize[k]= 0;
 
     func= (matHeader **)Alloc( _nfunc*sizeof( matHeader * ) );
-    for ( k= _nfunc-1; k >= 0; k-- ) 
-        func[k]= (matHeader *)Alloc( _max*sizeof( matHeader ) );
+    for ( k= _nfunc-1; k >= 0; k-- )
+        func[k]= (matHeader *)Alloc( _max*sizeof( matHeader ) );
 }
 
@@ -110 +110 @@
     matElem * elemp;
     for ( k= _nfunc-1; k >= 0; k-- ) {
-        for ( l= _size-1, colp= func[k]; l >= 0; l--, colp++ ) {
-            if ( ( colp->owner == TRUE ) && ( colp->size > 0 ) ) {
-                for ( row= colp->size-1, elemp= colp->elems; row >= 0; row--, elemp++ )
-                    nDelete( & elemp->elem );
-                Free( (ADDRESS)colp->elems, colp->size*sizeof( matElem ) );
-            }
-        }
-        Free( (ADDRESS)func[k], _max*sizeof( matHeader ) );
+        for ( l= _size-1, colp= func[k]; l >= 0; l--, colp++ ) {
+            if ( ( colp->owner == TRUE ) && ( colp->size > 0 ) ) {
+                for ( row= colp->size-1, elemp= colp->elems; row >= 0; row--, elemp++ )
+                    nDelete( & elemp->elem );
+                Free( (ADDRESS)colp->elems, colp->size*sizeof( matElem ) );
+            }
+        }
+        Free( (ADDRESS)func[k], _max*sizeof( matHeader ) );
     }
     Free( (ADDRESS)func, _nfunc*sizeof( matHeader * ) );
@@ -124 +124 @@
 
 void
-idealFunctionals::endofConstruction() 
+idealFunctionals::endofConstruction()
 {
     _size= currentSize[0];
@@ -130 +130 @@
 
 void
-idealFunctionals::map( ring source ) 
+idealFunctionals::map( ring source )
 {
     // maps from ring source to currentRing.
@@ -141 +141 @@
     maFindPerm( source->names, source->N, NULL, 0, currRing->names, currRing->N, NULL, 0, perm, NULL );
     nSetMap( source->ch, source->parameter, source->P, source->minpoly );
-    
+
     matHeader ** temp = (matHeader **)Alloc( _nfunc*sizeof( matHeader * ));
     for ( var= 0; var < _nfunc; var ++ ) {
-        for ( col= 0, colp= func[var]; col < _size; col++, colp++ ) {
-            if ( colp->owner == TRUE ) {
-                for ( row= colp->size-1, elemp= colp->elems; row >= 0; row--, elemp++ ) {
-                    newelem= nMap( elemp->elem );
-                    nDelete( & elemp->elem );
-                    elemp->elem= newelem;
-                }
-            }
-        }
-        temp[ perm[var+1]-1 ]= func[var];
+        for ( col= 0, colp= func[var]; col < _size; col++, colp++ ) {
+            if ( colp->owner == TRUE ) {
+                for ( row= colp->size-1, elemp= colp->elems; row >= 0; row--, elemp++ ) {
+                    newelem= nMap( elemp->elem );
+                    nDelete( & elemp->elem );
+                    elemp->elem= newelem;
+                }
+            }
+        }
+        temp[ perm[var+1]-1 ]= func[var];
     }
     Free( (ADDRESS)func, _nfunc*sizeof( matHeader * ) );
@@ -161 +161 @@
 
 matHeader *
-idealFunctionals::grow( int var ) 
+idealFunctionals::grow( int var )
 {
     if ( currentSize[var-1] == _max ) {
-        int k;
-        for ( k= _nfunc; k > 0; k-- )
-            func[k-1]= (matHeader *)ReAlloc( func[k-1], _max*sizeof( matHeader ), (_max + _block)*sizeof( matHeader ) );
-        _max+= _block;
+        int k;
+        for ( k= _nfunc; k > 0; k-- )
+            func[k-1]= (matHeader *)ReAlloc( func[k-1], _max*sizeof( matHeader ), (_max + _block)*sizeof( matHeader ) );
+        _max+= _block;
     }
     currentSize[var-1]++;
-    return func[var-1] + currentSize[var-1] - 1;  
+    return func[var-1] + currentSize[var-1] - 1;
 }
 
@@ -183 +183 @@
     elems->elem= nInit( 1 );
     for ( k= divisors[0]; k > 0; k-- ) {
-        fglmASSERT( 0 < divisors[k] && divisors[k] <= _nfunc, "wrong divisor" );
-        matHeader * colp = grow( divisors[k] );
-        colp->size= 1;
-        colp->elems= elems;
-        colp->owner= owner;
-        owner= FALSE;
-    }
-}
-
-    
+        fglmASSERT( 0 < divisors[k] && divisors[k] <= _nfunc, "wrong divisor" );
+        matHeader * colp = grow( divisors[k] );
+        colp->size= 1;
+        colp->elems= elems;
+        colp->owner= owner;
+        owner= FALSE;
+    }
+}
+
+
 void
 idealFunctionals::insertCols( int * divisors, const fglmVector to )
@@ -204 +204 @@
     BOOLEAN owner = TRUE;
     if ( numElems > 0 ) {
-        elems= (matElem *)Alloc( numElems * sizeof( matElem ) );
-        for ( k= 1, l= 1, elemp= elems; k <= numElems; k++, elemp++ ) {
-            while ( nIsZero( to.getconstelem(l) ) ) l++;
-            elemp->row= l;
-            elemp->elem= nCopy( to.getconstelem( l ) );
-            l++; // hochzaehlen, damit wir nicht noch einmal die gleiche Stelle testen
-        }
+        elems= (matElem *)Alloc( numElems * sizeof( matElem ) );
+        for ( k= 1, l= 1, elemp= elems; k <= numElems; k++, elemp++ ) {
+            while ( nIsZero( to.getconstelem(l) ) ) l++;
+            elemp->row= l;
+            elemp->elem= nCopy( to.getconstelem( l ) );
+            l++; // hochzaehlen, damit wir nicht noch einmal die gleiche Stelle testen
+        }
     }
     else
-        elems= NULL;
+        elems= NULL;
     for ( k= divisors[0]; k > 0; k-- ) {
-        fglmASSERT( 0 < divisors[k] && divisors[k] <= _nfunc, "wrong divisor" );
-        matHeader * colp = grow( divisors[k] );
-        colp->size= numElems;
-        colp->elems= elems;
-        colp->owner= owner;
-        owner= FALSE;
+        fglmASSERT( 0 < divisors[k] && divisors[k] <= _nfunc, "wrong divisor" );
+        matHeader * colp = grow( divisors[k] );
+        colp->size= numElems;
+        colp->elems= elems;
+        colp->owner= owner;
+        owner= FALSE;
     }
 }
@@ -236 +236 @@
     fglmASSERT( currentSize[var-1]+1 >= vsize, "wrong v.size()" );
     for ( k= 1, colp= func[var-1]; k <= vsize; k++, colp++ ) {
-        factor= v.getconstelem( k );
-        if ( ! nIsZero( factor ) ) {
-            for ( l= colp->size-1, elemp= colp->elems; l >= 0; l--, elemp++ ) {
-                temp= nMult( factor, elemp->elem );
-                number newelem= nAdd( result.getconstelem( elemp->row ), temp );
-                nDelete( & temp );
-                nNormalize( newelem );
-                result.setelem( elemp->row, newelem );
-            }    
-        }
+        factor= v.getconstelem( k );
+        if ( ! nIsZero( factor ) ) {
+            for ( l= colp->size-1, elemp= colp->elems; l >= 0; l--, elemp++ ) {
+                temp= nMult( factor, elemp->elem );
+                number newelem= nAdd( result.getconstelem( elemp->row ), temp );
+                nDelete( & temp );
+                nNormalize( newelem );
+                result.setelem( elemp->row, newelem );
+            }
+        }
     }
     return result;
@@ -260 +260 @@
     int k, l;
     for ( k= 1, colp= func[var-1]; k <= _size; k++, colp++ ) {
-        factor= v.getconstelem( k );
-        if ( ! nIsZero( factor ) ) {
-            for ( l= colp->size-1, elemp= colp->elems; l >= 0; l--, elemp++ ) {
-                temp= nMult( factor, elemp->elem );
-                number newelem= nAdd( result.getconstelem( elemp->row ), temp );
-                nDelete( & temp );
-                nNormalize( newelem );
-                result.setelem( elemp->row, newelem );
-            }
-        }
+        factor= v.getconstelem( k );
+        if ( ! nIsZero( factor ) ) {
+            for ( l= colp->size-1, elemp= colp->elems; l >= 0; l--, elemp++ ) {
+                temp= nMult( factor, elemp->elem );
+                number newelem= nAdd( result.getconstelem( elemp->row ), temp );
+                nDelete( & temp );
+                nNormalize( newelem );
+                result.setelem( elemp->row, newelem );
+            }
+        }
     }
     return result;
@@ -275 +275 @@
 
 // ============================================================
-//!      The old basis 
+//!      The old basis
 // ============================================================
 
@@ -283 +283 @@
 //      the basis when the normalForm was computed.
 //     monom gets deleted when borderElem comes out of scope.
-class borderElem 
+class borderElem
 {
 public:
@@ -292 +292 @@
     ~borderElem() { pDelete1( &monom ); }
 #ifndef HAVE_EXPLICIT_CONSTR
-    void insertElem( poly p, fglmVector n ) 
+    void insertElem( poly p, fglmVector n )
     {
-        monom= p;
-        nf= n;
+        monom= p;
+        nf= n;
     }
 #endif
@@ -303 +303 @@
 //     The declaration of class fglmSelem is found in fglm.h
 
-fglmSelem::fglmSelem( poly p, int var ) : numVars( 0 ), monom( p ) 
-{
-    for ( int k = pVariables; k > 0; k-- ) 
-        if ( pGetExp( monom, k ) > 0 ) 
-            numVars++;
+fglmSelem::fglmSelem( poly p, int var ) : numVars( 0 ), monom( p )
+{
+    for ( int k = pVariables; k > 0; k-- )
+        if ( pGetExp( monom, k ) > 0 )
+            numVars++;
     divisors= (int *)Alloc( (numVars+1)*sizeof( int ) );
     divisors[0]= 0;
@@ -313 +313 @@
 }
 
-void 
+void
 fglmSelem::cleanup()
 {
@@ -355 +355 @@
 };
 
-fglmSdata::fglmSdata( const ideal thisIdeal ) 
+fglmSdata::fglmSdata( const ideal thisIdeal )
 {
     // An dieser Stelle kann die BlockSize ( =BS ) noch sinnvoller berechnet
@@ -365 +365 @@
     basisMax= basisBS;
     basisSize= 0;
-    basis= (polyset)Alloc( basisMax*sizeof( poly ) );  
+    basis= (polyset)Alloc( basisMax*sizeof( poly ) );
 
     borderBS= 100;
@@ -382 +382 @@
 {
     for ( int k = basisSize; k > 0; k-- )
-        pDelete1( basis + k );  //. rem: basis runs from basis[1]..basis[basisSize]
+        pDelete1( basis + k );  //. rem: basis runs from basis[1]..basis[basisSize]
     Free( (ADDRESS)basis, basisMax*sizeof( poly ) );
 #ifndef HAVE_EXPLICIT_CONSTR
@@ -388 +388 @@
 #else
     for ( int l = borderSize; l > 0; l-- )
-        // rem: the polys of borderElem are deleted via ~borderElem()
-        border[l].~borderElem();
+        // rem: the polys of borderElem are deleted via ~borderElem()
+        border[l].~borderElem();
     Free( (ADDRESS)border, borderMax*sizeof( borderElem ) );
 #endif
 }
 
-//     Inserts poly p without copying into basis, reAllocs Memory if necessary, 
+//     Inserts poly p without copying into basis, reAllocs Memory if necessary,
 //      increases basisSize and returns the new basisSize.
 //     Remember: The elements of basis are deleted via pDelete in ~fglmSdata!
 //     Sets m= NULL to indicate that now basis is ow(e?)ing the poly.
 int
-fglmSdata::newBasisElem( poly & m ) 
+fglmSdata::newBasisElem( poly & m )
 {
     basisSize++;
     if ( basisSize == basisMax ) {
-        basis= (polyset)ReAlloc( basis, basisMax*sizeof( poly ), (basisMax + basisBS)*sizeof( poly ) );
-        basisMax+= basisBS;
+        basis= (polyset)ReAlloc( basis, basisMax*sizeof( poly ), (basisMax + basisBS)*sizeof( poly ) );
+        basisMax+= basisBS;
     }
     basis[basisSize]= m;
@@ -411 +411 @@
 }
 
-//     Inserts poly p and fglmvector v without copying into border, reAllocs Memory 
+//     Inserts poly p and fglmvector v without copying into border, reAllocs Memory
 //      if necessary, and increases borderSize.
 //     Remember: The poly of border is deleted via ~borderElem in ~fglmSdata!
@@ -421 +421 @@
     if ( borderSize == borderMax ) {
 #ifndef HAVE_EXPLICIT_CONSTR
-        borderElem * tempborder = new borderElem[ borderMax+borderBS ];
-        for ( int k = 0; k < borderMax; k++ ) {
-            tempborder[k]= border[k];
-            border[k].insertElem( NULL, fglmVector() );
-        }
-        delete [] border;
-        border= tempborder;
+        borderElem * tempborder = new borderElem[ borderMax+borderBS ];
+        for ( int k = 0; k < borderMax; k++ ) {
+            tempborder[k]= border[k];
+            border[k].insertElem( NULL, fglmVector() );
+        }
+        delete [] border;
+        border= tempborder;
 #else
-        border= (borderElem *)ReAlloc( border, borderMax*sizeof( borderElem ), (borderMax + borderBS)*sizeof( borderElem ) );
+        border= (borderElem *)ReAlloc( border, borderMax*sizeof( borderElem ), (borderMax + borderBS)*sizeof( borderElem ) );
 #endif
-        borderMax+= borderBS;
+        borderMax+= borderBS;
     }
 #ifndef HAVE_EXPLICIT_CONSTR
@@ -449 +449 @@
 }
 
-//     Multiplies basis[basisSize] with all ringvariables and inserts the new monomials 
+//     Multiplies basis[basisSize] with all ringvariables and inserts the new monomials
 //      into the list of candidates, according to the given order. If a monomial already
-//      exists, then "insertions" and "divisors" are updated. 
-//     Assumes that ringvar(k) < ringvar(l) for k > l 
+//      exists, then "insertions" and "divisors" are updated.
+//     Assumes that ringvar(k) < ringvar(l) for k > l
 void
 fglmSdata::updateCandidates()
@@ -464 +464 @@
     int state = 0;
     while ( k >= 1 ) {
-        newmonom = pCopy( m );  
-        pIncrExp( newmonom, k );
-        pSetm( newmonom );
-        done= FALSE;
-        while ( list.hasItem() && (done == FALSE) ) {
-            if ( (state= pComp( list.getItem().monom, newmonom )) < 0 )
-                list++;
-            else done= TRUE;
-        }
-        if ( done == FALSE ) {
-            nlist.append( fglmSelem( newmonom, k ) );
-            break;
-        }
-        if ( state == 0 ) {
-            list.getItem().newDivisor( k );
-            pDelete1( &newmonom );
-        }
-        else {
-            list.insert( fglmSelem( newmonom, k ) );
-        }
-        k--;
+        newmonom = pCopy( m );
+        pIncrExp( newmonom, k );
+        pSetm( newmonom );
+        done= FALSE;
+        while ( list.hasItem() && (done == FALSE) ) {
+            if ( (state= pComp( list.getItem().monom, newmonom )) < 0 )
+                list++;
+            else done= TRUE;
+        }
+        if ( done == FALSE ) {
+            nlist.append( fglmSelem( newmonom, k ) );
+            break;
+        }
+        if ( state == 0 ) {
+            list.getItem().newDivisor( k );
+            pDelete1( &newmonom );
+        }
+        else {
+            list.insert( fglmSelem( newmonom, k ) );
+        }
+        k--;
     }
     while ( --k >= 1 ) {
-        newmonom= pCopy( m ); // HIER
-        pIncrExp( newmonom, k );
-        pSetm( newmonom );
-        nlist.append( fglmSelem( newmonom, k ) );
+        newmonom= pCopy( m ); // HIER
+        pIncrExp( newmonom, k );
+        pSetm( newmonom );
+        nlist.append( fglmSelem( newmonom, k ) );
     }
 }
@@ -498 +498 @@
 //      coefficients.)
 int
-fglmSdata::getEdgeNumber( const poly m ) const 
-{
-    for ( int k = idelems; k > 0; k-- ) 
-        if ( pEqual( m, (theIdeal->m)[k-1] ) )
-            return k;
+fglmSdata::getEdgeNumber( const poly m ) const
+{
+    for ( int k = idelems; k > 0; k-- )
+        if ( pEqual( m, (theIdeal->m)[k-1] ) )
+            return k;
     return 0;
 }
 
-//     Returns the fglmVector v, s.t. 
+//     Returns the fglmVector v, s.t.
 //        p = v[1]*basis(1) + .. + v[basisSize]*basis(basisSize)
 //     So the size of v depends on the current size of the basis.
@@ -512 +512 @@
 //      smaller than basis[basisSize] and that basis[k] < basis[l] for k < l.
 fglmVector
-fglmSdata::getVectorRep( const poly p ) 
+fglmSdata::getVectorRep( const poly p )
 {
     fglmVector temp( basisSize );
@@ -518 +518 @@
     int num = basisSize;
     while ( m != NULL ) {
-        int comp = pComp( m, basis[num] );
-        if ( comp == 0 ) {
-            fglmASSERT( num > 0, "Error(1) in fglmSdata::getVectorRep" );
-            number newelem = nCopy( pGetCoeff( m ) );
-            temp.setelem( num, newelem );
-            num--;
-            pIter( m );
-        }
-        else { 
-            if ( comp < 0 ) {
-                num--;
-            }
-            else {
-                // This is the place where we can detect if the sourceIdeal
-                // is not reduced. In this case m is not in basis[]. Since basis[]
-                // is ordered this is then and only then the case, if basis[i]<m
-                // and basis[j]>m for all j>i
-                _state= FALSE;
-                return temp;
-            }
-        }
+        int comp = pComp( m, basis[num] );
+        if ( comp == 0 ) {
+            fglmASSERT( num > 0, "Error(1) in fglmSdata::getVectorRep" );
+            number newelem = nCopy( pGetCoeff( m ) );
+            temp.setelem( num, newelem );
+            num--;
+            pIter( m );
+        }
+        else {
+            if ( comp < 0 ) {
+                num--;
+            }
+            else {
+                // This is the place where we can detect if the sourceIdeal
+                // is not reduced. In this case m is not in basis[]. Since basis[]
+                // is ordered this is then and only then the case, if basis[i]<m
+                // and basis[j]>m for all j>i
+                _state= FALSE;
+                return temp;
+            }
+        }
     }
     return temp;
@@ -545 +545 @@
 //     Searches through the border for a monomoial bm which devides m and returns
 //      its normalform in vector representation.
-//     var contains the number of the variable v, s.t. bm = m * v 
+//     var contains the number of the variable v, s.t. bm = m * v
 fglmVector
 fglmSdata::getBorderDiv( const poly m, int & var ) const
@@ -551 +551 @@
 //     int num2 = borderSize;
 //     while ( num2 > 0 ) {
-//      poly temp = border[num2].monom;
-//      if ( pDivisibleBy( temp, m ) ) {
-//          poly divisor = pDivideM( m, temp );
-//          int var = pIsPurePower( divisor );
-//          if ( (var != 0) && (pGetCoeff( divisor, var ) == 1) ) {
-//              Print( "poly %s divides poly %s", pString( temp ), pString( m ) );
-//          }
-//      }
-//      num2--;
+//         poly temp = border[num2].monom;
+//         if ( pDivisibleBy( temp, m ) ) {
+//             poly divisor = pDivideM( m, temp );
+//             int var = pIsPurePower( divisor );
+//             if ( (var != 0) && (pGetCoeff( divisor, var ) == 1) ) {
+//                 Print( "poly %s divides poly %s", pString( temp ), pString( m ) );
+//             }
+//         }
+//         num2--;
 //     }
     int num = borderSize;
     while ( num > 0 ) {
-        poly temp = border[num].monom;
-        if ( pDivisibleBy( temp, m ) ) {
-            var = pVariables;
-            while ( var > 0 ) {
-                if ( (pGetExp( m, var ) - pGetExp( temp, var )) == 1 ) 
-                    return border[num].nf;
-                var--;
-            }
-        }
-        num--;
+        poly temp = border[num].monom;
+        if ( pDivisibleBy( temp, m ) ) {
+            var = pVariables;
+            while ( var > 0 ) {
+                if ( (pGetExp( m, var ) - pGetExp( temp, var )) == 1 )
+                    return border[num].nf;
+                var--;
+            }
+        }
+        num--;
     }
     return fglmVector();
 }
 
-//     Calculates the defining Functionals for the ideal "theIdeal" and 
+//     Calculates the defining Functionals for the ideal "theIdeal" and
 //     returns them in "l".
 //     The ideal has to be zero-dimensional and reduced and has to be a
 //     real subset of the polynomal ring.
-//     In any case it has to be zero-dimensional and minimal (check this 
+//     In any case it has to be zero-dimensional and minimal (check this
 //      via fglmIdealcheck). Any minimal but not reduced ideal is detected.
 //      In this case it returns FglmNotReduced.
@@ -600 +600 @@
     STICKYPROT(".");
     while ( data.candidatesLeft() == TRUE ) {
-        fglmSelem candidate = data.nextCandidate();
-        if ( candidate.isBasisOrEdge() == TRUE ) {
-            int edge = data.getEdgeNumber( candidate.monom );
-            if ( edge != 0 ) {
-                // now candidate is an edge, i.e. we know its normalform:
-                // NF(p) = - ( tail(p)/LC(p) )
-                poly nf = data.getSpanPoly( edge );
-                pNorm( nf );
-                pDelete1( &nf );  //. deletes the leadingmonomial
-                nf= pNeg( nf );
-                fglmVector nfv = data.getVectorRep( nf );
-                l.insertCols( candidate.divisors, nfv );
-                data.newBorderElem( candidate.monom, nfv );
-                pDelete( &nf );
-                STICKYPROT( "+" );
-            }
-            else {
-                int basis= data.newBasisElem( candidate.monom );
-                data.updateCandidates();
-                l.insertCols( candidate.divisors, basis );
-                STICKYPROT( "." );
-            }
-        }
-        else {
-            int var = 0;
-            fglmVector temp = data.getBorderDiv( candidate.monom, var );
-            fglmASSERT( var > 0, "this should never happen" );
-            fglmVector nfv = l.addCols( var, data.getBasisSize(), temp );
-            data.newBorderElem( candidate.monom, nfv );
-            l.insertCols( candidate.divisors, nfv );
-            STICKYPROT( "-" );
-        }
-        candidate.cleanup();
+        fglmSelem candidate = data.nextCandidate();
+        if ( candidate.isBasisOrEdge() == TRUE ) {
+            int edge = data.getEdgeNumber( candidate.monom );
+            if ( edge != 0 ) {
+                // now candidate is an edge, i.e. we know its normalform:
+                // NF(p) = - ( tail(p)/LC(p) )
+                poly nf = data.getSpanPoly( edge );
+                pNorm( nf );
+                pDelete1( &nf );  //. deletes the leadingmonomial
+                nf= pNeg( nf );
+                fglmVector nfv = data.getVectorRep( nf );
+                l.insertCols( candidate.divisors, nfv );
+                data.newBorderElem( candidate.monom, nfv );
+                pDelete( &nf );
+                STICKYPROT( "+" );
+            }
+            else {
+                int basis= data.newBasisElem( candidate.monom );
+                data.updateCandidates();
+                l.insertCols( candidate.divisors, basis );
+                STICKYPROT( "." );
+            }
+        }
+        else {
+            int var = 0;
+            fglmVector temp = data.getBorderDiv( candidate.monom, var );
+            fglmASSERT( var > 0, "this should never happen" );
+            fglmVector nfv = l.addCols( var, data.getBasisSize(), temp );
+            data.newBorderElem( candidate.monom, nfv );
+            l.insertCols( candidate.divisors, nfv );
+            STICKYPROT( "-" );
+        }
+        candidate.cleanup();
     } //. while ( data.candidatesLeft() == TRUE )
     l.endofConstruction();
@@ -645 +645 @@
 //     The declaration of class fglmDelem is found in fglm.h
 
-fglmDelem::fglmDelem( poly & m, fglmVector mv, int v ) : insertions( 0 ), v( mv ), var( v ) 
-{
-    monom= m; 
+fglmDelem::fglmDelem( poly & m, fglmVector mv, int v ) : insertions( 0 ), v( mv ), var( v )
+{
+    monom= m;
     m= NULL;
     for ( int k = pVariables; k > 0; k-- )
-        if ( pGetExp( monom, k ) > 0 )
-            insertions++;
+        if ( pGetExp( monom, k ) > 0 )
+            insertions++;
     // Wir gehen davon aus, dass ein fglmDelem direkt bei der Erzeugung
     // auch in eine Liste eingefuegt wird. Daher wird hier automatisch
@@ -662 +662 @@
 {
     if ( monom != NULL ) {
-        pDelete1( &monom );
+        pDelete1( &monom );
     }
 }
@@ -679 +679 @@
     oldGaussElem( const fglmVector newv, const fglmVector newp, number & newpdenom, number & newfac ) : v( newv ), p( newp ), pdenom( newpdenom ), fac( newfac )
     {
-        newpdenom= NULL;
-        newfac= NULL;
+        newpdenom= NULL;
+        newfac= NULL;
     }
     ~oldGaussElem();
 #ifndef HAVE_EXPLICIT_CONSTR
-    void insertElem( const fglmVector newv, const fglmVector newp, number & newpdenom, number & newfac ) 
+    void insertElem( const fglmVector newv, const fglmVector newp, number & newpdenom, number & newfac )
     {
-        v= newv;
-        p= newp;
-        pdenom= newpdenom;
-        fac= newfac;
-        newpdenom= NULL;
-        newfac= NULL;
+        v= newv;
+        p= newp;
+        pdenom= newpdenom;
+        fac= newfac;
+        newpdenom= NULL;
+        newfac= NULL;
     }
 #endif
@@ -703 +703 @@
 
 
-class fglmDdata 
+class fglmDdata
 {
 private:
@@ -712 +712 @@
     int basisSize;  //. the CURRENT basisSize, i.e. basisSize <= dimen
     polyset basis;  // [1]..[dimen]. The monoms of the new Vectorspace-basis
-    
+
     int groebnerBS;
     int groebnerSize;
@@ -729 +729 @@
     void newGroebnerPoly( fglmVector & v, poly & p );
     void gaussreduce( fglmVector & v, fglmVector & p, number & denom );
-    ideal buildIdeal() 
+    ideal buildIdeal()
     {
-        idSkipZeroes( destId );
-        return destId;
+        idSkipZeroes( destId );
+        return destId;
     }
 };
@@ -763 +763 @@
     delete [] gauss;
 #else
-    for ( k= dimen; k > 0; k-- ) 
-        gauss[k].~oldGaussElem();
+    for ( k= dimen; k > 0; k-- )
+        gauss[k].~oldGaussElem();
     Free( (ADDRESS)gauss, (dimen+1)*sizeof( oldGaussElem ) );
 #endif
@@ -771 +771 @@
     //. Remember: There is no poly in basis[0], thus k > 0
     for ( k= dimen; k > 0; k-- )
-        pDelete1( basis + k );
+        pDelete1( basis + k );
     Free( (ADDRESS)basis, (dimen+1)*sizeof( poly ) );
 }
 
 fglmDelem
-fglmDdata::nextCandidate() 
+fglmDdata::nextCandidate()
 {
     fglmDelem result = nlist.getFirst();
@@ -783 +783 @@
 }
 
-void 
+void
 fglmDdata::newBasisElem( poly & m, fglmVector v, fglmVector p, number & denom )
 {
@@ -793 +793 @@
     int k= 1;
     while ( nIsZero(v.getconstelem(k)) || isPivot[k] ) {
-        k++;
+        k++;
     }
     fglmASSERT( k <= dimen, "Error(1) in fglmDdata::pivot-search");
@@ -800 +800 @@
     k++;
     while ( k <= dimen ) {
-        if ( ! nIsZero( v.getconstelem(k) ) && ! isPivot[k] ) {
-            if ( nGreater( v.getconstelem( k ), pivot ) ) {
-                pivot= v.getconstelem( k );
-                pivotcol= k;
-            }
-        }
-        k++;
+        if ( ! nIsZero( v.getconstelem(k) ) && ! isPivot[k] ) {
+            if ( nGreater( v.getconstelem( k ), pivot ) ) {
+                pivot= v.getconstelem( k );
+                pivotcol= k;
+            }
+        }
+        k++;
     }
     fglmASSERT( ! nIsZero( pivot ), "Error(2) fglmDdata::Pivotelement ist Null" );
     isPivot[ pivotcol ]= TRUE;
     perm[basisSize]= pivotcol;
-    
+
     pivot= nCopy( v.getconstelem( pivotcol ) );
 #ifndef HAVE_EXPLICIT_CONSTR
@@ -829 +829 @@
     int state = 0;
     while ( k >= 1 ) {
-        newmonom = pCopy( m );
-        pIncrExp( newmonom, k );
-        pSetm( newmonom );
-        done= FALSE;
-        while ( list.hasItem() && (done == FALSE) ) {
-            if ( (state= pComp( list.getItem().monom, newmonom )) < 0 )
-                list++;
-            else done= TRUE;
-        }
-        if ( done == FALSE ) {
-            nlist.append( fglmDelem( newmonom, v, k ) );
-            break;
-        }
-        if ( state == 0 ) {
-            list.getItem().newDivisor();
-            pDelete1( & newmonom );
-        }
-        else {
-            list.insert( fglmDelem( newmonom, v, k ) );
-        }
-        k--;
+        newmonom = pCopy( m );
+        pIncrExp( newmonom, k );
+        pSetm( newmonom );
+        done= FALSE;
+        while ( list.hasItem() && (done == FALSE) ) {
+            if ( (state= pComp( list.getItem().monom, newmonom )) < 0 )
+                list++;
+            else done= TRUE;
+        }
+        if ( done == FALSE ) {
+            nlist.append( fglmDelem( newmonom, v, k ) );
+            break;
+        }
+        if ( state == 0 ) {
+            list.getItem().newDivisor();
+            pDelete1( & newmonom );
+        }
+        else {
+            list.insert( fglmDelem( newmonom, v, k ) );
+        }
+        k--;
     }
     while ( --k >= 1 ) {
-        newmonom= pCopy( m );
-        pIncrExp( newmonom, k );
-        pSetm( newmonom );
-        nlist.append( fglmDelem( newmonom, v, k ) );
-    }
-}
-
-void 
-fglmDdata::newGroebnerPoly( fglmVector & p, poly & m ) 
+        newmonom= pCopy( m );
+        pIncrExp( newmonom, k );
+        pSetm( newmonom );
+        nlist.append( fglmDelem( newmonom, v, k ) );
+    }
+}
+
+void
+fglmDdata::newGroebnerPoly( fglmVector & p, poly & m )
 // Inserts gp = p[1]*basis(1)+..+p[basisSize]*basis(basisSize)+p[basisSize+1]*m as
 //  a new groebner polynomial for the ideal.
@@ -873 +873 @@
     m= NULL;
     if ( nGetChar() > 0 ) {
-        number lead = nCopy( p.getconstelem( basisSize+1 ) );
-        p /= lead; 
-        nDelete( & lead );
+        number lead = nCopy( p.getconstelem( basisSize+1 ) );
+        p /= lead;
+        nDelete( & lead );
     }
     if ( nGetChar() == 0 ) {
-        number gcd= p.gcd();
-        fglmASSERT( ! nIsZero( gcd ), "FATAL: gcd and thus p is zero" );
-        if ( ! nIsOne( gcd ) ) 
-            p /= gcd;
-        nDelete( & gcd );
+        number gcd= p.gcd();
+        fglmASSERT( ! nIsZero( gcd ), "FATAL: gcd and thus p is zero" );
+        if ( ! nIsOne( gcd ) )
+            p /= gcd;
+        nDelete( & gcd );
     }
     pSetCoeff( result, nCopy( p.getconstelem( basisSize+1 ) ) );
     for ( k= basisSize; k > 0; k-- ) {
-        if ( ! nIsZero( p.getconstelem( k ) ) ) {
-            temp->next= pCopy( basis[k] );
-            pIter( temp );
-            pSetCoeff( temp, nCopy( p.getconstelem( k ) ) );
-        }
+        if ( ! nIsZero( p.getconstelem( k ) ) ) {
+            temp->next= pCopy( basis[k] );
+            pIter( temp );
+            pSetCoeff( temp, nCopy( p.getconstelem( k ) ) );
+        }
     }
     pSetm( result );
     if ( ! nGreaterZero( pGetCoeff( result ) ) ) result= pNeg( result );
     if ( groebnerSize == IDELEMS( destId ) ) {
-        pEnlargeSet( & destId->m, IDELEMS( destId ), groebnerBS );
-        IDELEMS( destId )+= groebnerBS;
+        pEnlargeSet( & destId->m, IDELEMS( destId ), groebnerBS );
+        IDELEMS( destId )+= groebnerBS;
     }
     (destId->m)[groebnerSize]= result;
@@ -903 +903 @@
 
 void
-fglmDdata::gaussreduce( fglmVector & v, fglmVector & p, number & pdenom ) 
+fglmDdata::gaussreduce( fglmVector & v, fglmVector & p, number & pdenom )
 {
     int k;
@@ -912 +912 @@
     number vdenom = v.clearDenom();
     if ( ! nIsOne( vdenom ) && ! nIsZero( vdenom ) ) {
-        p.setelem( p.size(), vdenom );
+        p.setelem( p.size(), vdenom );
     }
     else {
-        nDelete( &vdenom );
+        nDelete( &vdenom );
     }
     number gcd = v.gcd();
     if ( ! nIsOne( gcd ) && ! nIsZero( gcd ) ) {
-        v /= gcd;
-        number temp= nMult( pdenom, gcd );
-        nDelete( &pdenom );
-        pdenom= temp;
+        v /= gcd;
+        number temp= nMult( pdenom, gcd );
+        nDelete( &pdenom );
+        pdenom= temp;
     }
     nDelete( & gcd );
@@ -928 +928 @@
     for ( k= 1; k <= basisSize; k++ ) {
 
-        if ( ! v.elemIsZero( perm[k] ) ) {
-            fac1= gauss[k].fac;
-            fac2= nCopy( v.getconstelem( perm[k] ) );
-            v.nihilate( fac1, fac2, gauss[k].v );
-            fac1= nMult( fac1, gauss[k].pdenom );
-            temp= nMult( fac2, pdenom );
-            nDelete( &fac2 );
-            fac2= temp;
-            p.nihilate( fac1, fac2, gauss[k].p );
-            temp= nMult( pdenom, gauss[k].pdenom );
-            nDelete( &pdenom );
-            pdenom= temp;
-
-            nDelete( & fac1 );
-            nDelete( & fac2 );
-            number gcd = v.gcd();
-            if ( ! nIsOne( gcd ) && ! nIsZero( gcd ) ) {
-                v /= gcd;
-                number temp= nMult( pdenom, gcd );
-                nDelete( &pdenom );
-                pdenom= temp;
-            }
-            nDelete( & gcd );
-            gcd= p.gcd();
-            temp= nGcd( pdenom, gcd );
-            nDelete( &gcd );
-            gcd= temp;
-            if ( ! nIsZero( gcd ) && ! nIsOne( gcd ) ) {
-                p /= gcd;
-                temp= nDiv( pdenom, gcd );
-                nDelete( & pdenom );
-                pdenom= temp;
-                nNormalize( pdenom );
-            }
-            nDelete( & gcd );
-        }
+        if ( ! v.elemIsZero( perm[k] ) ) {
+            fac1= gauss[k].fac;
+            fac2= nCopy( v.getconstelem( perm[k] ) );
+            v.nihilate( fac1, fac2, gauss[k].v );
+            fac1= nMult( fac1, gauss[k].pdenom );
+            temp= nMult( fac2, pdenom );
+            nDelete( &fac2 );
+            fac2= temp;
+              p.nihilate( fac1, fac2, gauss[k].p );
+            temp= nMult( pdenom, gauss[k].pdenom );
+            nDelete( &pdenom );
+            pdenom= temp;
+
+            nDelete( & fac1 );
+            nDelete( & fac2 );
+            number gcd = v.gcd();
+            if ( ! nIsOne( gcd ) && ! nIsZero( gcd ) ) {
+                v /= gcd;
+                number temp= nMult( pdenom, gcd );
+                nDelete( &pdenom );
+                pdenom= temp;
+            }
+            nDelete( & gcd );
+            gcd= p.gcd();
+            temp= nGcd( pdenom, gcd );
+            nDelete( &gcd );
+            gcd= temp;
+            if ( ! nIsZero( gcd ) && ! nIsOne( gcd ) ) {
+                p /= gcd;
+                temp= nDiv( pdenom, gcd );
+                nDelete( & pdenom );
+                pdenom= temp;
+                nNormalize( pdenom );
+            }
+            nDelete( & gcd );
+        }
     }
 }
@@ -971 +971 @@
 // Calculates the groebnerBasis for the ideal which is defined by l.
 // The dimension of l has to be finite.
-// The result is in reduced form. 
+// The result is in reduced form.
 {
     fglmDdata data( l.dimen() );
-    
+
     // insert pOne() and update workinglist:
     poly one = pOne();
@@ -982 +982 @@
     STICKYPROT( "." );
     while ( data.candidatesLeft() == TRUE ) {
-        fglmDelem candidate = data.nextCandidate();
-        if ( candidate.isBasisOrEdge() == TRUE ) {
-            // Now we have the chance to find a new groebner polynomial
-            
-            // v is the vector-representation of candidate.monom
-            // some elements of v are zeroed in data.gaussreduce(). Which
-            // ones and how this was done is stored in p.
-            // originalV containes the unchanged v, which is later inserted
-            // into the working list (via data.updateCandidates().
-            fglmVector v = l.multiply( candidate.v, candidate.var );
-            fglmVector originalV = v;
-            fglmVector p( data.getBasisSize()+1, data.getBasisSize()+1 );
-            number pdenom = NULL;
-            data.gaussreduce( v, p, pdenom );
-            if ( v.isZero() ) {
-                // Now v is linear dependend to the already found basis elements.
-                // This means that v (rsp. candidate.monom) is the leading
-                // monomial of the next groebner-basis polynomial.
-                data.newGroebnerPoly( p, candidate.monom );
-                nDelete( & pdenom );
-                STICKYPROT( "+" );
-            }
-            else {
-                // no linear dependence could be found, so v ( rsp. monom )
-                // is a basis monomial. We store the zeroed version ( i.e. v
-                // and not originalV ) as well as p, the denomiator and all
-                // the other stuff.
-                // erst updateCandidates, dann newBasisELem!!!
-                data.updateCandidates( candidate.monom, originalV );
-                data.newBasisElem( candidate.monom, v, p, pdenom );
-                STICKYPROT( "." );
-            }
-        }
-        else {
-            STICKYPROT( "-" );
-            candidate.cleanup();
-        }
+        fglmDelem candidate = data.nextCandidate();
+        if ( candidate.isBasisOrEdge() == TRUE ) {
+            // Now we have the chance to find a new groebner polynomial
+
+            // v is the vector-representation of candidate.monom
+            // some elements of v are zeroed in data.gaussreduce(). Which
+            // ones and how this was done is stored in p.
+            // originalV containes the unchanged v, which is later inserted
+            // into the working list (via data.updateCandidates().
+            fglmVector v = l.multiply( candidate.v, candidate.var );
+            fglmVector originalV = v;
+            fglmVector p( data.getBasisSize()+1, data.getBasisSize()+1 );
+            number pdenom = NULL;
+            data.gaussreduce( v, p, pdenom );
+            if ( v.isZero() ) {
+                // Now v is linear dependend to the already found basis elements.
+                // This means that v (rsp. candidate.monom) is the leading
+                // monomial of the next groebner-basis polynomial.
+                data.newGroebnerPoly( p, candidate.monom );
+                nDelete( & pdenom );
+                STICKYPROT( "+" );
+            }
+            else {
+                // no linear dependence could be found, so v ( rsp. monom )
+                // is a basis monomial. We store the zeroed version ( i.e. v
+                // and not originalV ) as well as p, the denomiator and all
+                // the other stuff.
+                // erst updateCandidates, dann newBasisELem!!!
+                data.updateCandidates( candidate.monom, originalV );
+                data.newBasisElem( candidate.monom, v, p, pdenom );
+                STICKYPROT( "." );
+            }
+        }
+        else {
+            STICKYPROT( "-" );
+            candidate.cleanup();
+        }
     }  //. while data.candidatesLeft()
     STICKYPROT( "\n" );
@@ -1031 +1031 @@
     fglmVector p;
     ideal destIdeal = idInit( pVariables, 1 );
-    
+
     int i;
     BOOLEAN isZero;
     for ( i= 1; i <= pVariables; i++ ) {
-        // main loop
-        STICKYPROT2( "(%i)", i );
-        gaussReducer gauss( l.dimen() );
-        isZero= FALSE;
-        v= fglmVector( l.dimen(), 1 );
-        while ( isZero == FALSE ) {
-            if ( (isZero= gauss.reduce( v )) == TRUE ) {
-                STICKYPROT( "+" );
-                p= gauss.getDependence();
-                number gcd= p.gcd();
-                if ( ! nIsOne( gcd ) ) {
-                    p /= gcd;
-                }
-                nDelete( & gcd );
-                int k;
-                poly temp = NULL;
-                poly result;
-                for ( k= p.size(); k > 0; k-- ) {
-                    number n = nCopy( p.getconstelem( k ) );
-                    if ( ! nIsZero( n ) ) {
-                        if ( temp == NULL ) {
-                            result= pOne();
-                            temp= result;
-                        }
-                        else {
-                            temp->next= pOne();
-                            pIter( temp );
-                        }
-                        pSetCoeff( temp, n );
-                        pSetExp( temp, i, k-1 );
-                        pSetm( temp );
-                    }
-                }
-                if ( ! nGreaterZero( pGetCoeff( result ) ) ) result= pNeg( result );
-                (destIdeal->m)[i-1]= result;
-            }
-            else {
-                STICKYPROT( "." );
-                gauss.store();
-                v= l.multiply( v, i );
-            }
-        }
+        // main loop
+        STICKYPROT2( "(%i)", i );
+        gaussReducer gauss( l.dimen() );
+        isZero= FALSE;
+        v= fglmVector( l.dimen(), 1 );
+        while ( isZero == FALSE ) {
+            if ( (isZero= gauss.reduce( v )) == TRUE ) {
+                STICKYPROT( "+" );
+                p= gauss.getDependence();
+                number gcd= p.gcd();
+                if ( ! nIsOne( gcd ) ) {
+                    p /= gcd;
+                }
+                nDelete( & gcd );
+                int k;
+                poly temp = NULL;
+                poly result;
+                for ( k= p.size(); k > 0; k-- ) {
+                    number n = nCopy( p.getconstelem( k ) );
+                    if ( ! nIsZero( n ) ) {
+                        if ( temp == NULL ) {
+                            result= pOne();
+                            temp= result;
+                        }
+                        else {
+                            temp->next= pOne();
+                            pIter( temp );
+                        }
+                        pSetCoeff( temp, n );
+                        pSetExp( temp, i, k-1 );
+                        pSetm( temp );
+                    }
+                }
+                if ( ! nGreaterZero( pGetCoeff( result ) ) ) result= pNeg( result );
+                (destIdeal->m)[i-1]= result;
+            }
+            else {
+                STICKYPROT( "." );
+                gauss.store();
+                v= l.multiply( v, i );
+            }
+        }
     }
     STICKYPROT( "\n" );
@@ -1088 +1088 @@
     idhdl initialRingHdl = currRingHdl;
     BOOLEAN fglmok;
-    
+
     if ( currRingHdl != sourceRingHdl )
-        rSetHdl( sourceRingHdl, TRUE );
+        rSetHdl( sourceRingHdl, TRUE );
     idealFunctionals L( 100, pVariables );
     fglmok = CalculateFunctionals( sourceIdeal, L );
     if ( deleteIdeal == TRUE )
-        idDelete( & sourceIdeal );
+        idDelete( & sourceIdeal );
     rSetHdl( destRingHdl, TRUE );
     if ( fglmok == TRUE ) {
-        L.map( IDRING( sourceRingHdl ) );
-        destIdeal= GroebnerViaFunctionals( L );
+        L.map( IDRING( sourceRingHdl ) );
+        destIdeal= GroebnerViaFunctionals( L );
     }
     if ( (switchBack == TRUE) && (currRingHdl != initialRingHdl) )
-        rSetHdl( initialRingHdl, TRUE );
+        rSetHdl( initialRingHdl, TRUE );
     return fglmok;
 }
 
 BOOLEAN
-FindUnivariateWrapper( ideal source, ideal & destIdeal ) 
+FindUnivariateWrapper( ideal source, ideal & destIdeal )
 {
     BOOLEAN fglmok;
-    
+
     idealFunctionals L( 100, pVariables );
     fglmok = CalculateFunctionals( source, L );
     if ( fglmok == TRUE ) {
-        destIdeal= FindUnivariatePolys( L );
-        return TRUE;
-    }
-    else 
-        return FALSE;
+        destIdeal= FindUnivariatePolys( L );
+        return TRUE;
+    }
+    else
+        return FALSE;
 }
 

Singular/getopt.h

@@ -19 +19 @@
 #define _GETOPT_H 1
 
-#ifdef  __cplusplus
+#ifdef        __cplusplus
 extern "C" {
 #endif
@@ -60 +60 @@
 
    The field `has_arg' is:
-   no_argument          (or 0) if the option does not take an argument,
-   required_argument    (or 1) if the option requires an argument,
-   optional_argument    (or 2) if the option takes an optional argument.
+   no_argument                (or 0) if the option does not take an argument,
+   required_argument        (or 1) if the option requires an argument,
+   optional_argument         (or 2) if the option takes an optional argument.
 
    If the field `flag' is not NULL, it points to a variable that is set
@@ -77 +77 @@
 struct option
 {
-#if     __STDC__
+#if        __STDC__
   const char *name;
 #else
@@ -91 +91 @@
 /* Names for the values of the `has_arg' field of `struct option'.  */
 
-#define no_argument             0
-#define required_argument       1
-#define optional_argument       2
+#define        no_argument                0
+#define required_argument        1
+#define optional_argument        2
 
 #if __STDC__ || defined(PROTO) || defined(__MWERKS__)
@@ -103 +103 @@
 #endif /* not __GNU_LIBRARY__ */
 extern int getopt_long (int argc, char *const *argv, const char *shortopts,
-                        const struct option *longopts, int *longind);
+                        const struct option *longopts, int *longind);
 extern int getopt_long_only (int argc, char *const *argv,
-                             const char *shortopts,
-                             const struct option *longopts, int *longind);
+                             const char *shortopts,
+                             const struct option *longopts, int *longind);
 
 /* Internal only.  Users should not call this directly.  */
 extern int _getopt_internal (int argc, char *const *argv,
-                             const char *shortopts,
-                             const struct option *longopts, int *longind,
-                             int long_only);
+                             const char *shortopts,
+                             const struct option *longopts, int *longind,
+                             int long_only);
 #else /* not __STDC__ */
 extern int getopt ();
@@ -121 +121 @@
 #endif /* not __STDC__ */
 
-#ifdef  __cplusplus
+#ifdef        __cplusplus
 }
 #endif

Singular/hdegree.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: hdegree.cc,v 1.12 1998-04-08 10:01:58 pohl Exp $ */
+/* $Id: hdegree.cc,v 1.13 1998-09-24 09:59:42 Singular Exp $ */
 /*
 *  ABSTRACT -  dimension, multiplicity, HC, kbase
@@ -1158 +1158 @@
       if (stc[i] && (stc[i][Nvar] >= y))
       {
-        Istc--;
-        stc[i] = NULL;
+        Istc--;
+        stc[i] = NULL;
       }
     }
@@ -1267 +1267 @@
       {
         Istc--;
-        sn[i] = NULL;
+        sn[i] = NULL;
       }
     }
@@ -1282 +1282 @@
       if (sn[i])
       {
-        sn[j] = sn[i];
-        j++;
+        sn[j] = sn[i];
+        j++;
       }
     }
@@ -1328 +1328 @@
       {
         Istc--;
-        sn[i] = NULL;
+        sn[i] = NULL;
       }
     }
@@ -1338 +1338 @@
       if (sn[i])
       {
-        sn[j] = sn[i];
-        j++;
+        sn[j] = sn[i];
+        j++;
       }
     }

Singular/hutil.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: hutil.cc,v 1.7 1998-04-27 10:19:04 pohl Exp $ */
+/* $Id: hutil.cc,v 1.8 1998-09-24 09:59:43 Singular Exp $ */
 /*
 * ABSTRACT: Utilities for staircase operations
@@ -117 +117 @@
 }
 
-  
+
 void hComp(scfmon exist, int Nexist, Exponent_t ak, scfmon stc, int *Nstc)
 {
@@ -224 +224 @@
          g -= o;
        else
-         g = o - g;
+         g = o - g;
        if (g > h)
          h = g;

Singular/intvec.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR      *
 *****************************************/
-/* $Id: intvec.cc,v 1.9 1998-05-24 09:51:50 obachman Exp $ */
+/* $Id: intvec.cc,v 1.10 1998-09-24 09:59:43 Singular Exp $ */
 /*
 * ABSTRACT: class intvec: lists/vectors of integers
@@ -110 +110 @@
         }
       }
-      if (j+1<row) 
+      if (j+1<row)
       {
         StringAppend("\n");
         if (spaces>0) StringAppend("%-*.*s",spaces,spaces," ");
-      }  
+      }
     }
   }
@@ -158 +158 @@
   if (intop == 0) return;
   if (intop<0) intop*=(-1);
-  for (int i=0; i<row*col; i++) 
+  for (int i=0; i<row*col; i++)
   { v[i] %= intop; if (v[i]<0) v[i] += intop; }
 }
@@ -164 +164 @@
 int intvec::compare(intvec* op)
 {
-  if ((col!=1) ||(op->cols()!=1)) 
+  if ((col!=1) ||(op->cols()!=1))
   {
     if((col!=op->cols())
     || (row!=op->rows()))
       return -2;
-  }    
+  }
   int i;
   for (i=0; i<min(length(),op->length()); i++)

Singular/ipconv.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: ipconv.cc,v 1.10 1998-05-28 16:50:49 Singular Exp $ */
+/* $Id: ipconv.cc,v 1.11 1998-09-24 09:59:44 Singular Exp $ */
 /*
 * ABSTRACT: automatic type conversions
@@ -171 +171 @@
 static void * iiR2L(void * data)
 {
-  return (void *)syConvRes((syStrategy)data);  
+  return (void *)syConvRes((syStrategy)data);
 }
 
 static void * iiL2R(void * data)
 {
-  return (void *)syConvList((lists)data);  
+  return (void *)syConvList((lists)data);
 }
 #else
@@ -237 +237 @@
 //  link
    { STRING_CMD,      LINK_CMD,       iiS2Link },
-// resolution -> list   
+// resolution -> list
    { RESOLUTION_CMD,  LIST_CMD,       iiR2L },
 // list -> resolution

Singular/ipid.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: ipid.cc,v 1.16 1998-09-09 13:10:26 Singular Exp $ */
+/* $Id: ipid.cc,v 1.17 1998-09-24 09:59:44 Singular Exp $ */
 
 /*
@@ -126 +126 @@
       case PROC_CMD:
         len=sizeof(procinfo);
-        break;
+        break;
     //other types: without init (int,script,poly,def,package)
     }
@@ -421 +421 @@
   else Print("=======>%s(%x)<====\n", IDID(h), IDID(h));
 #endif
-  
+
   FreeL((ADDRESS)IDID(h));
   //IDID(h)=NULL;
@@ -722 +722 @@
 #if 0
   if(init && ns->isroot) {
-    idhdl pl = enterid( mstrdup("Top"),0, PACKAGE_CMD, 
+    idhdl pl = enterid( mstrdup("Top"),0, PACKAGE_CMD,
                       &NSROOT(namespaceroot), TRUE );
     if(pl != NULL) {

Singular/ipid.h

@@ -4 +4 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: ipid.h,v 1.15 1998-08-25 13:33:18 krueger Exp $ */
+/* $Id: ipid.h,v 1.16 1998-09-24 09:59:45 Singular Exp $ */
 /*
 * ABSTRACT: identfier handling
@@ -150 +150 @@
 #define NSROOT(a) ((a)->pack->idroot)
 #define NSPACK(a) ((a)->pack)
-  
+
 
  namerec()  { memset(this,0,sizeof(*this)); }

Singular/khstd.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: khstd.cc,v 1.6 1998-05-14 13:04:15 Singular Exp $ */
+/* $Id: khstd.cc,v 1.7 1998-09-24 09:59:46 Singular Exp $ */
 /*
 * ABSTRACT:utils for hilbert driven kStd
@@ -75 +75 @@
               PrintS("h");
               mflush();
-            }  
+            }
             deleteInL(strat->L,&strat->Ll,strat->Ll,strat);
           }
@@ -93 +93 @@
         PrintS("h");
         mflush();
-      }  
+      }
       deleteInL(strat->L,&strat->Ll,strat->Ll,strat);
     }

Singular/lists.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: lists.cc,v 1.10 1998-06-18 08:17:41 Singular Exp $ */
+/* $Id: lists.cc,v 1.11 1998-09-24 09:59:46 Singular Exp $ */
 /*
 * ABSTRACT: handling of the list type
@@ -217 +217 @@
         {
           L->m[i].rtyp=typ0;
-          int j=IDELEMS(r[0])-1;
-          while ((j>0) && (r[0]->m[j]==NULL)) j--;
-          j++;
-          if (j!=IDELEMS(r[0]))
-          {
-            pEnlargeSet(&(r[0]->m),IDELEMS(r[0]),j-IDELEMS(r[0]));
-            IDELEMS(r[0])=j;
-          }
+          int j=IDELEMS(r[0])-1;
+          while ((j>0) && (r[0]->m[j]==NULL)) j--;
+          j++;
+          if (j!=IDELEMS(r[0]))
+          {
+            pEnlargeSet(&(r[0]->m),IDELEMS(r[0]),j-IDELEMS(r[0]));
+            IDELEMS(r[0])=j;
+          }
         }
         else

Singular/longalg.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: longalg.cc,v 1.24 1998-04-23 09:52:14 Singular Exp $ */
+/* $Id: longalg.cc,v 1.25 1998-09-24 09:59:47 Singular Exp $ */
 /*
 * ABSTRACT:   algebraic numbers
@@ -1017 +1017 @@
   if (!naIsChar0) x = napInit(1);
   else            x = napGcd0(g,h);
-  //int huhu=0;
   for (i=(naNumbOfPar-1); i>=0; i--)
   {
     x->e[i] = napExpi(i,a,b);
-    //huhu+=x->e[i];
-  }
-  //if (huhu!=0) 
-  //{
-  //  Print("{%d}",huhu);
-  //}
+  }
   return x;
 }

Singular/maps.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: maps.cc,v 1.10 1998-05-14 13:04:20 Singular Exp $ */
+/* $Id: maps.cc,v 1.11 1998-09-24 09:59:49 Singular Exp $ */
 /*
 * ABSTRACT - the mapping of polynomials to other rings
@@ -42 +42 @@
   int i,modulComp;
   int varnum = preimage_r->N;
-  
+
 //  for(i=1; i<=varnum; i++)
 //  {

Singular/mmalloc.c

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: mmalloc.c,v 1.5 1998-01-24 17:22:06 Singular Exp $ */
+/* $Id: mmalloc.c,v 1.6 1998-09-24 09:59:49 Singular Exp $ */
 
 /*
@@ -92 +92 @@
 void _memcpyW(void* p1, void* p2, long l)
 {
-  long _i = l;                                  
-  long* _s1 = (long*) p1;                       
-  const long* _s2 = (long*) p2;                 
-                                                
-  for (;;)                                      
-  {                                             
-    *_s1 = *_s2;                                
-    _i--;                                       
-    if (_i == 0) break;                         
-    _s1++;                                      
-    _s2++;                                      
-  }                                             
-}                                               
-#endif  
+  long _i = l;
+  long* _s1 = (long*) p1;
+  const long* _s2 = (long*) p2;
 
+  for (;;)
+  {
+    *_s1 = *_s2;
+    _i--;
+    if (_i == 0) break;
+    _s1++;
+    _s2++;
+  }
+}
+#endif
+