Changeset d4cb43b in git

Timestamp:

Jan 30, 2002, 3:33:07 PM (22 years ago)

Author:

Hans Schönemann <hannes@…>

Branches:

(u'spielwiese', '8e0ad00ce244dfd0756200662572aef8402f13d5')

Children:

c658ed43f0faca30bee15dba7bad146606a58727

Parents:

70981176bc24302d6a91e9beb7523f2aec93937a

Message:

* hannes: icc-port (code cleanup)


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

Location:

Singular

Files:

• kstd1.cc (modified) (2 diffs)
• kstd2.cc (modified) (3 diffs)
• longalg.cc (modified) (6 diffs)
• longalg.h (modified) (2 diffs)
• misc.cc (modified) (3 diffs)
• mpr_base.cc (modified) (3 diffs)
• numbers.cc (modified) (2 diffs)
• numbers.h (modified) (2 diffs)
• pInline0.h (modified) (3 diffs)
• p_Procs_Generate.cc (modified) (3 diffs)
• p_Procs_Impl.h (modified) (34 diffs)
• syz2.cc (modified) (15 diffs)
• syz3.cc (modified) (63 diffs)
• tok.h (modified) (4 diffs)

Singular/kstd1.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: kstd1.cc,v 1.85 2001-08-28 11:49:48 Singular Exp $ */
+/* $Id: kstd1.cc,v 1.86 2002-01-30 14:33:01 Singular Exp $ */
 /*
 * ABSTRACT:
@@ -682 +682 @@
 * in the case of looking for the pure powers
 */
-int posInL10 (LSet const set, int length, LObject* p,kStrategy const strat)
+int posInL10 (const LSet set,const int length, LObject* p,const kStrategy strat)
 {
   int j,dp,dL;

Singular/kstd2.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: kstd2.cc,v 1.75 2001-08-27 14:47:05 Singular Exp $ */
+/* $Id: kstd2.cc,v 1.76 2002-01-30 14:33:02 Singular Exp $ */
 /*
 *  ABSTRACT -  Kernel: alg. of Buchberger
@@ -33 +33 @@
 //        number of first divisor, otherwise
 int kFindDivisibleByInT(const TSet &T, const unsigned long* sevT,
-                        const int tl, const LObject* L, int start)
+                        const int tl, const LObject* L, const int start)
 {
   unsigned long not_sev = ~L->sev;
@@ -601 +601 @@
       int pos=posInS(strat,strat->sl,strat->P.p,strat->P.ecart);
 
-      // reduce the tail and normailze poly
+      // reduce the tail and normalize poly
       if (TEST_OPT_INTSTRATEGY)
       {

Singular/longalg.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: longalg.cc,v 1.63 2002-01-10 12:33:21 Singular Exp $ */
+/* $Id: longalg.cc,v 1.64 2002-01-30 14:33:02 Singular Exp $ */
 /*
 * ABSTRACT:   algebraic numbers
@@ -52 +52 @@
 static number   (*nacGcd)(number a, number b, const ring r);
 static number   (*nacLcm)(number a, number b, const ring r);
-static void     (*nacDelete)(number *a, ring r);
+static void     (*nacDelete)(number *a, const ring r);
        number   (*nacInit)(int i);
 static int      (*nacInt)(number &n);
@@ -253 +253 @@
 }
 
-void nap_Delete(napoly *p, ring r)
+void nap_Delete(napoly *p, const ring r)
 {
   napoly w, h = *p;
@@ -1370 +1370 @@
 *  deletes p
 */
-void naDelete(number *p, ring r)
+void naDelete(number *p, const ring r)
 {
   lnumber l = (lnumber) * p;
@@ -2061 +2061 @@
 * result =gcd(a,b)
 */
-number naGcd(number a, number b, ring r)
+number naGcd(number a, number b, const ring r)
 {
   lnumber x, y;
@@ -2355 +2355 @@
 * and in     result->z the lcm(a->z,b->n)
 */
-number naLcm(number la, number lb, ring r)
+number naLcm(number la, number lb, const ring r)
 {
   lnumber result;

Singular/longalg.h

@@ -4 +4 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: longalg.h,v 1.28 2002-01-10 12:33:22 Singular Exp $ */
+/* $Id: longalg.h,v 1.29 2002-01-30 14:33:03 Singular Exp $ */
 /*
 * ABSTRACT:   algebraic numbers
@@ -47 +47 @@
 #define napLength(p)      pLength((poly)p)
 napoly napNeg(napoly a);
-void    naDelete (number *p, ring r);
+void    naDelete (number *p, const ring r);
 #else /* LONGALGNEW */
 void    naDelete (number *p, const ring r);

Singular/misc.cc

@@ -303 +303 @@
 {
   char * name;
-  int   setval;
-  int   resetval;
+  unsigned   setval;
+  unsigned   resetval;
 };
 
@@ -701 +701 @@
           else
             PrintLn();
-        }  
+        }
         hh=IDNEXT(hh);
       }
@@ -726 +726 @@
               Print("%s::%s, typ %s level %d data %x\n",
               IDID(hh),IDID(h2),Tok2Cmdname(IDTYP(h2)),IDLEV(h2),IDDATA(h2));
-            }  
+            }
             h2=IDNEXT(h2);
           }

Singular/mpr_base.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: mpr_base.cc,v 1.27 2001-08-27 14:47:12 Singular Exp $ */
+/* $Id: mpr_base.cc,v 1.28 2002-01-30 14:33:04 Singular Exp $ */
 
 /*
@@ -2445 +2445 @@
 }
 
-resVector *resMatrixDense::getMVector(int i)
+resVector *resMatrixDense::getMVector(const int i)
 {
   assume( i >= 0 && i < numVectors );
@@ -3160 +3160 @@
 }
 
-int uResultant::nextPrime( int i )
+int uResultant::nextPrime( const int i )
 {
   int init=i;
-  i+=2;
-  int j= IsPrime( i );
+  int ii=i+2;
+  int j= IsPrime( ii );
   while ( j <= init )
   {
-    i+=2;
-    j= IsPrime( i );
+    ii+=2;
+    j= IsPrime( ii );
   }
   return j;

Singular/numbers.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR      *
 *****************************************/
-/* $Id: numbers.cc,v 1.43 2001-08-24 14:10:09 Singular Exp $ */
+/* $Id: numbers.cc,v 1.44 2002-01-30 14:33:04 Singular Exp $ */
 
 /*
@@ -79 +79 @@
 int    ndParDeg(number n) { return 0; }
 
-number ndGcd(number a, number b, ring r) { return r->cf->nInit(1); }
+number ndGcd(number a, number b, const ring r) { return r->cf->nInit(1); }
 
 number ndIntMod(number a, number b) { return nInit(0); }

Singular/numbers.h

@@ -4 +4 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: numbers.h,v 1.27 2001-03-22 19:11:08 Singular Exp $ */
+/* $Id: numbers.h,v 1.28 2002-01-30 14:33:05 Singular Exp $ */
 /*
 * ABSTRACT: interface to coefficient aritmetics
@@ -70 +70 @@
 void ndDelete(number* d, const ring r);
 void nDummy2(number &d);
-number ndGcd(number a, number b);
+number ndGcd(number a, number b, const ring r);
 number ndCopy(number a);
 number nd_Copy(number a, ring r);

Singular/pInline0.h

@@ -7 +7 @@
  *  Author:  obachman (Olaf Bachmann)
  *  Created: 8/00
- *  Version: $Id: pInline0.h,v 1.8 2001-08-27 14:47:20 Singular Exp $
+ *  Version: $Id: pInline0.h,v 1.9 2002-01-30 14:33:05 Singular Exp $
  *******************************************************************/
 #ifndef PINLINE0_H
@@ -112 +112 @@
 }
 
-BOOLEAN   p_IsConstantPoly(poly p, ring r)
+BOOLEAN   p_IsConstantPoly(const poly p, const ring r)
 {
-  while(p!=NULL)
+  poly pp=p;
+  while(pp!=NULL)
   {
-    if (! p_LmIsConstantComp(p, r))
+    if (! p_LmIsConstantComp(pp, r))
       return FALSE;
-    pIter(p);
+    pIter(pp);
   }
   return TRUE;
@@ -182 +183 @@
 
 #endif // PINLINE_CC
+

Singular/p_Procs_Generate.cc

@@ -8 +8 @@
  *  Author:  obachman (Olaf Bachmann)
  *  Created: 8/00
- *  Version: $Id: p_Procs_Generate.cc,v 1.5 2001-08-27 14:47:28 Singular Exp $
+ *  Version: $Id: p_Procs_Generate.cc,v 1.6 2002-01-30 14:33:05 Singular Exp $
  *******************************************************************/
 
@@ -243 +243 @@
 #ifdef p_Procs_Static
   int j;
-  printf("
-/***************************************************************
-  Names of procs for RDEBUG */
-#ifdef RDEBUG\n");
+  printf("\n"
+  "/***************************************************************\n"
+  "Names of procs for RDEBUG */\n"
+  "#ifdef RDEBUG\n");
 
   for (i=0; i<p_Unknown_Proc; i++)
@@ -264 +264 @@
     printf("\n};\n");
   }
-  printf("
-#endif // RDEBUG
-
-
-/***************************************************************/
-/* Tables for lookup of procedures: */\n");
+  printf("\n #endif // RDEBUG\n\n"
+  "/***************************************************************/\n"
+  "/* Tables for lookup of procedures: */\n");
 
   for (i=0; i<p_Unknown_Proc; i++)

Singular/p_Procs_Impl.h

@@ -7 +7 @@
  *  Author:  obachman (Olaf Bachmann)
  *  Created: 12/00
- *  Version: $Id: p_Procs_Impl.h,v 1.6 2001-10-09 16:36:16 Singular Exp $
+ *  Version: $Id: p_Procs_Impl.h,v 1.7 2002-01-30 14:33:05 Singular Exp $
  *******************************************************************/
 #ifndef P_PROCS_IMPL_H
@@ -13 +13 @@
 
 /***************************************************************
- *
+ *  
  * Configurations
- *
+ * 
  *******************************************************************/
 
 /***************************************************************
  Here is how it works:
- At run-time, SetProcs is used to choose the appropriate PolyProcs
+ At run-time, SetProcs is used to choose the appropriate PolyProcs 
               based on the ring properies.
- At generate-time, SetProcs is used to generate all
+ At generate-time, SetProcs is used to generate all 
               possible PolyProcs.
- Which PolyProcs are generated/used can be controled by values of
+ Which PolyProcs are generated/used can be controled by values of 
  HAVE_FAST_P_PROCS, HAVE_FAST_LENGTH, HAVE_FAST_ORD, and FAST_FIELD
-
+ 
  At generate-time, the file p_Procs.inc is generated,
  which provides implementations of the p_Procs, based on
@@ -32 +32 @@
  macros.
 
- At run-time, a fast proc is set/choosen if found/generated, else
+ At run-time, a fast proc is set/choosen if found/generated, else 
  a general proc is set/choosen.
  *******************************************************************/
@@ -52 +52 @@
 //   2 -- plus special cases for FieldQ
 //   nothing else is implemented, yet
-#ifndef HAVE_FAST_FIELD
+#ifndef HAVE_FAST_FIELD 
 #define HAVE_FAST_FIELD 0
 #endif
@@ -62 +62 @@
 //   3 -- special cases for length <= 4
 //   4 -- special cases for length <= 8
-#ifndef HAVE_FAST_LENGTH
+#ifndef HAVE_FAST_LENGTH 
 #define HAVE_FAST_LENGTH 0
 #endif
@@ -72 +72 @@
 //  3  -- special ords for with n_min <= 3
 //  4  -- special for all ords
-#ifndef HAVE_FAST_ORD
+#ifndef HAVE_FAST_ORD 
 #define HAVE_FAST_ORD 0
 #endif
 
 // Define HAVE_FAST_ZERO_ORD to:
-//  0 -- no zero ords are considered
+//  0 -- no zero ords are considered 
 //  1 -- only ZeroOrds for OrdPosNomogPosZero, OrdNomogPosZero, OrdPomogNegZero
 //  2 -- ZeroOrds for all
-#ifndef HAVE_FAST_ZERO_ORD
+#ifndef HAVE_FAST_ZERO_ORD 
 #define HAVE_FAST_ZERO_ORD 0
 #endif
@@ -94 +94 @@
 
 /***************************************************************
- *
+ *  
  * Definitions of our fields, lengths, ords, procs we work with
- *
+ * 
  *******************************************************************/
 
@@ -106 +106 @@
 {
   FieldGeneral = 0,
-  FieldZp,
+  FieldZp,          
   FieldQ,
   FieldR,
@@ -117 +117 @@
 #endif
   FieldUnknown
-};
+} p_Field;
 typedef enum p_Length // Length of exponent vector in words
 {
   LengthGeneral = 0, // n >= 1
-  LengthEight,       // n == 8
+  LengthEight,       // n == 8   
   LengthSeven,
   LengthSix,
@@ -130 +130 @@
   LengthOne,
   LengthUnknown
-};
-typedef enum p_Ord
-{
-  OrdGeneral = 0,
-                    //     ordsgn
+} p_Length;
+typedef enum p_Ord  
+{                   
+  OrdGeneral = 0,   
+                    //     ordsgn   
                     //  0   1   i   n-1 n   n_min   Example
   OrdPomog,         //  +   +   +   +   +   1       (lp,C)
@@ -172 +172 @@
 
   OrdUnknown
-};
+} p_Ord;
 
 typedef enum p_Proc
@@ -192 +192 @@
   p_kBucketSetLm_Proc,
   p_Unknown_Proc
-};
+} p_Proc;
 
 static inline char* p_FieldEnum_2_String(p_Field field)
@@ -199 +199 @@
   {
       case FieldGeneral: return "FieldGeneral";
-      case FieldZp: return "FieldZp";
+      case FieldZp: return "FieldZp";          
       case FieldQ: return "FieldQ";
       case FieldR: return "FieldR";
@@ -218 +218 @@
   switch(length)
   {
-      case LengthGeneral: return "LengthGeneral";
-      case LengthEight: return "LengthEight";
+      case LengthGeneral: return "LengthGeneral"; 
+      case LengthEight: return "LengthEight";       
       case LengthSeven: return "LengthSeven";
       case LengthSix: return "LengthSix";
@@ -236 +236 @@
   switch(ord)
   {
-      case OrdGeneral: return "OrdGeneral";
-      case OrdPomog: return "OrdPomog";
-      case OrdNomog: return "OrdNomog";
-      case OrdNegPomog: return "OrdNegPomog";
-      case OrdPomogNeg: return "OrdPomogNeg";
-      case OrdPosNomog: return "OrdPosNomog";
-      case OrdNomogPos: return "OrdNomogPos";
-      case OrdPosPosNomog: return "OrdPosPosNomog";
-      case OrdPosNomogPos: return "OrdPosNomogPos";
-      case OrdNegPosNomog: return "OrdNegPosNomog";
+      case OrdGeneral: return "OrdGeneral";   
+      case OrdPomog: return "OrdPomog";         
+      case OrdNomog: return "OrdNomog";         
+      case OrdNegPomog: return "OrdNegPomog";      
+      case OrdPomogNeg: return "OrdPomogNeg";      
+      case OrdPosNomog: return "OrdPosNomog";      
+      case OrdNomogPos: return "OrdNomogPos";      
+      case OrdPosPosNomog: return "OrdPosPosNomog";   
+      case OrdPosNomogPos: return "OrdPosNomogPos";   
+      case OrdNegPosNomog: return "OrdNegPosNomog";   
 #ifdef HAVE_LENGTH_DIFF
-      case OrdNegPomogZero: return "OrdNegPomogZero";
-      case OrdPomogNegZero: return "OrdPomogNegZero";
-      case OrdPomogZero: return "OrdPomogZero";
-      case OrdNomogZero: return "OrdNomogZero";
-      case OrdNomogPosZero: return "OrdNomogPosZero";
-      case OrdPosNomogZero: return "OrdPosNomogZero";
+      case OrdNegPomogZero: return "OrdNegPomogZero";  
+      case OrdPomogNegZero: return "OrdPomogNegZero";  
+      case OrdPomogZero: return "OrdPomogZero";     
+      case OrdNomogZero: return "OrdNomogZero";     
+      case OrdNomogPosZero: return "OrdNomogPosZero";  
+      case OrdPosNomogZero: return "OrdPosNomogZero";  
       case OrdPosPosNomogZero: return "OrdPosPosNomogZero";
       case OrdPosNomogPosZero: return "OrdPosNomogPosZero";
@@ -304 +304 @@
       case p_Merge_q_Proc:
         return 1;
-
+        
       default:
         return 0;
@@ -318 +318 @@
       case p_Neg_Proc:
         return 0;
-
+        
       default:
         return 1;
   }
 }
-
+  
 // returns string specifying the module into which the p_Proc
 // should go
@@ -338 +338 @@
 
 /***************************************************************
- *
- *
+ *  
+ * 
  * Deal with OrdZero
- *
+ * 
  *******************************************************************/
 #ifdef HAVE_LENGTH_DIFF
@@ -365 +365 @@
         case OrdPosPosNomogZero:    return OrdPosPosNomog;
         case OrdNegPosNomogZero:    return OrdNegPosNomog;
-        default:
+        default:    
           if (strict) return OrdGeneral;
           else if (ord == OrdPomogNegZero) return OrdPomogNeg;
@@ -384 +384 @@
 
 /***************************************************************
- *
- * Filters which are applied to field/length/ord, before a proc is
+ *  
+ * Filters which are applied to field/length/ord, before a proc is 
  * choosen
- *
+ * 
  *******************************************************************/
 #ifdef p_Procs_Static
-static inline void StaticKernelFilter(p_Field &field, p_Length &length,
+static inline void StaticKernelFilter(p_Field &field, p_Length &length, 
                                       p_Ord &ord, const p_Proc proc)
 {
@@ -407 +407 @@
 {
   if (HAVE_FAST_P_PROCS >= 5) return;
-
+  
   if (HAVE_FAST_P_PROCS < 3 && field == FieldQ)
     field = FieldGeneral;
-
+  
   if ((HAVE_FAST_P_PROCS == 0) ||
       (HAVE_FAST_P_PROCS <= 4 && field != FieldZp && field != FieldQ &&
@@ -420 +420 @@
     return;
   }
-  if (HAVE_FAST_P_PROCS == 1 ||
+  if (HAVE_FAST_P_PROCS == 1 || 
       (HAVE_FAST_P_PROCS == 4 && field != FieldZp && proc != p_Merge_q_Proc))
     ord = OrdGeneral;
@@ -427 +427 @@
 static inline void FastFieldFilter(p_Field &field)
 {
-  if (HAVE_FAST_FIELD <= 0 ||
+  if (HAVE_FAST_FIELD <= 0 || 
       (HAVE_FAST_FIELD == 1 && field != FieldZp) ||
       (field != FieldZp && field != FieldQ))
     field = FieldGeneral;
 }
-
+      
 static inline void FastLengthFilter(p_Length &length)
 {
@@ -457 +457 @@
   if (IsZeroOrd(ord))
   {
-    if ((HAVE_FAST_ZERO_ORD == 1 && (ord != OrdPosNomogPosZero &&
-                                     ord != OrdNomogPosZero &&
+    if ((HAVE_FAST_ZERO_ORD == 1 && (ord != OrdPosNomogPosZero && 
+                                     ord != OrdNomogPosZero && 
                                      ord != OrdPomogNegZero)) ||
         (HAVE_FAST_ZERO_ORD <= 0))
@@ -484 +484 @@
 }
 
-static inline void pp_Mult_mm_Noether_Filter(p_Field &field,
+static inline void pp_Mult_mm_Noether_Filter(p_Field &field, 
                                              p_Length &length, p_Ord &ord)
 {
-  if (ord == OrdPomog
+  if (ord == OrdPomog 
       || ord == OrdPomogZero
-      || (ord == OrdPomogNeg && length > LengthTwo)
+      || (ord == OrdPomogNeg && length > LengthTwo) 
 #ifdef HAVE_LENGTH_DIFF
       || (ord == OrdPomogZero)
@@ -502 +502 @@
   }
 }
-
-static inline void FastProcFilter(p_Proc proc, p_Field &field,
+      
+static inline void FastProcFilter(p_Proc proc, p_Field &field, 
                                   p_Length &length, p_Ord &ord)
 {
@@ -512 +512 @@
         p_Add_q__Filter(length, ord);
         break;
-
+        
       case p_Copy_Proc:
       case p_Delete_Proc:
         NCopy__Filter(field);
         break;
-
+        
       case pp_Mult_mm_Noether_Proc:
         pp_Mult_mm_Noether_Filter(field, length, ord);
@@ -531 +531 @@
           }
           break;
-
+          
       default: break;
   }
@@ -554 +554 @@
       ord > ORD_MAX_N_3)       //  i.e. OrdNomogPosZero and below
     return 0;
-
+  
   if (length >= LengthTwo &&    // i.e. 1 or 2
       ord > ORD_MAX_N_2)        // i.e. PosNomog and below
     return 0;
 
-  if (length == LengthOne &&
+  if (length == LengthOne && 
       ord > ORD_MAX_N_1)           // i.e. PosPomogZero and below
     return 0;
@@ -569 +569 @@
 }
 
-
+ 
 static inline int index(p_Length length, p_Ord ord)
 {
@@ -593 +593 @@
       case p_Neg_Proc:
         return field;
-
+        
       case p_ShallowCopyDelete_Proc:
         return length;
-
+        
       case p_Copy_Proc:
       case pp_Mult_mm_Proc:
@@ -610 +610 @@
       case p_kBucketSetLm_Proc:
         return index(field, length, ord);
-
+        
       case p_Merge_q_Proc:
         return index(length, ord);
-
+        
       default:
         assume(0);
@@ -623 +623 @@
 
 /***************************************************************
- *
- * Macros for setting procs -- these are used for
+ * 
+ * Macros for setting procs -- these are used for 
  * generation and setting
  *
@@ -639 +639 @@
 }                                                           \
 while (0)                                                   \
-
+  
 #define SetProcs(field, length, ord)                                    \
 do                                                                      \

Singular/syz2.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: syz2.cc,v 1.23 2001-08-27 14:47:42 Singular Exp $ */
+/* $Id: syz2.cc,v 1.24 2002-01-30 14:33:06 Singular Exp $ */
 /*
 * ABSTRACT: resolutions
@@ -82 +82 @@
   while ((l>0) && ((syzstr->resPairs[index])[l-1].lcm==NULL)) l--;
   rr = l-1;
-  while ((rr>=0) && (((syzstr->resPairs[index])[rr].p==NULL) ||
+  while ((rr>=0) && (((syzstr->resPairs[index])[rr].p==NULL) || 
         ((syzstr->resPairs[index])[rr].order>actdeg))) rr--;
-  r2 = rr+1;
+  r2 = rr+1; 
   while ((rr>=0) && ((syzstr->resPairs[index])[rr].order==actdeg)
          && ((syzstr->resPairs[index])[rr].syzind<0))
@@ -117 +117 @@
           if (tcp!=NULL)
           {
-            while ((tcp!=NULL) &&
+            while ((tcp!=NULL) && 
               ((tcp->first_poly!=i)||(tcp->second_poly!=r1))) tcp = tcp->next;
           }
@@ -128 +128 @@
             j = 0;
             while (j<i)
-            {
+            { 
               if (nP->m[j]!=NULL)
               {
@@ -169 +169 @@
                       while ((ti<l) && (((syzstr->resPairs[index])[ti].ind1!=j)||
                              ((syzstr->resPairs[index])[ti].ind2!=i))) ti++;
-                      if (ti<l)
+                      if (ti<l) 
                       {
 #ifdef SHOW_SPRFL
@@ -292 +292 @@
 {
   SObject tso;
+  memset(&tso,0,sizeof(tso));
   int l=(*syzstr->Tl)[index];
 
@@ -566 +567 @@
   while (kk>=0)
   {
-    if (toGo==0)
+    if (toGo==0) 
     {
       while (kk>=0)
@@ -612 +613 @@
         q = kBucketGetLm(syzstr->bucket);
         j = 0;
-        while (j<kres)
+        while (j<kres) 
         {
-          if ((redset[j].p!=NULL) && (pLmDivisibleBy(redset[j].p,q))
+          if ((redset[j].p!=NULL) && (pLmDivisibleBy(redset[j].p,q)) 
               && ((redset[j].ind1!=tso.ind1) || (redset[j].ind2!=tso.ind2)))
           {
@@ -756 +757 @@
       i = 0;
       delete spl1;
-      spl1 = ivStrip(spl2);
+      spl1 = ivStrip(spl2); 
       delete spl2;
       if (spl1!=NULL)
@@ -763 +764 @@
         kk = (*spl1)[i]-1;
       }
-    }
+    } 
 #endif
 #ifdef USE_HEURISTIC2
@@ -914 +915 @@
   for (i=1;i<=syzstr->length;i++)
   {
-    if (!idIs0(syzstr->orderedRes[i]))
+    if (!idIs0(syzstr->orderedRes[i])) 
     {
       toreor = syzstr->orderedRes[i];
@@ -927 +928 @@
         toreor->m[j] = NULL;
       }
-      m = 0;
+      m = 0; 
       for (j=0;j<togo;j++)
       {
@@ -948 +949 @@
 
 /*2
-* the CoCoA-algorithm for free resolutions, using a formula
+* the CoCoA-algorithm for free resolutions, using a formula 
 * for remaining pairs based on Hilbert-functions
 */
@@ -968 +969 @@
     return syzstr;
   }
-
+  
   // Creare dp,S ring and change to it
   syzstr->syRing = rCurrRingAssure_dp_C();
@@ -1082 +1083 @@
   kBucketDestroy(&(syzstr->bucket));
   kBucketDestroy(&(syzstr->syz_bucket));
-  if (origR != syzstr->syRing)
+  if (origR != syzstr->syRing)  
     rChangeCurrRing(origR);
   else

Singular/syz3.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: syz3.cc,v 1.9 2001-08-27 14:47:43 Singular Exp $ */
+/* $Id: syz3.cc,v 1.10 2002-01-30 14:33:06 Singular Exp $ */
 /*
 * ABSTRACT: resolutions
 */
-
+ 
 #include "mod2.h"
 #include <mylimits.h>
@@ -33 +33 @@
 #include "timer.h"
 #include "matpol.h"
-
+ 
 //#define SHOW_PROT
 //#define SHOW_RED
@@ -53 +53 @@
 int discard_pairs;
 int short_pairs;
-
-/*3
+ 
+/*3 
 * assumes the ideals old_ideal and new_ideal to be homogeneous
 * tests wether the new_ideal is a regular extension of the old_ideal
@@ -68 +68 @@
   int i;
   BOOLEAN isRegular=TRUE;
-
+ 
   for (i=old_hilbs->length()+deg-1;i>=deg;i--)
     (*shifted_old_hilbs)[i] = (*old_hilbs)[i-deg];
@@ -90 +90 @@
   return isRegular;
 }
-
+ 
 /*3
 * shows the resolution stored in syzstr->orderedRes
@@ -97 +97 @@
 {
   int i=0;
-
+ 
   while ((i<syzstr->length) && (!idIs0(syzstr->res[i])))
   {
@@ -108 +108 @@
   }
 }
-
+ 
 /*3
 * produces the next subresolution for a regular extension
@@ -123 +123 @@
   pSetComp(w_gen,0);
   pSetmComp(w_gen);
-
+  
   //syShowRes(syzstr);
   neg_gen = pNeg(neg_gen);
@@ -131 +131 @@
     pShift(&neg_gen,-1);
   }
-  while (index>0)
+  while (index>0) 
   {
     if (index%2==0)
@@ -203 +203 @@
             ppMult_qq(current_repr->m[i],p));
           syzstr->orderedRes[index]->m[i+start] = pCopy(current_repr->m[i]);
-          syzstr->orderedRes[index]->m[i+start] =
+          syzstr->orderedRes[index]->m[i+start] = 
             pMult_mm(syzstr->orderedRes[index]->m[i+start],w_gen);
           if ((*syzstr->Tl)[index]!=0)
@@ -215 +215 @@
           if ((index==1) && ((i==IDELEMS(current_ideal) ||
                (totake[index-1]->m[i+1]==NULL)))) break;
-          totake[index]->m[i+start_ttk] =
+          totake[index]->m[i+start_ttk] = 
             pMult_mm(pCopy(totake[index-1]->m[i]),w_gen);
           pShift(&totake[index]->m[i+start_ttk],current_tl);
@@ -234 +234 @@
   //syShowRes(syzstr);
 }
-
+ 
 /*3
 * proves the consistence of the pairset resPairs with the corresponding
@@ -243 +243 @@
 {
   int i=0;
-
-  while (i<length)
+ 
+  while (i<length) 
   {
     if (resPairs[i].lcm!=NULL)
@@ -256 +256 @@
   }
 }
-
+ 
 /*3
 * cancels the weight monomials given by the leading terms of totake
@@ -268 +268 @@
   resolvente res=syzstr->fullres;
   poly p;
-
+ 
   while ((syzIndex!=0) && (res[syzIndex]==NULL)) syzIndex--;
   while (syzIndex>0)
@@ -301 +301 @@
   }
 }
-
+ 
 /*3
 * updates the pairset resPairs by generating all pairs including the
@@ -320 +320 @@
   poly p=NULL;
   SObject tso;
-
+ 
   syInitializePair(&tso);
-  while ((og_elem<og_idel) && (old_generators->m[og_elem]!=NULL))
+  while ((og_elem<og_idel) && (old_generators->m[og_elem]!=NULL)) 
   {
     if ((index>0) && (pGetComp(old_generators->m[og_elem])<=crit_comp))
@@ -399 +399 @@
                 int ti=0;
                 while ((ti<l) && (((*resPairs)[ti].ind1!=j1)|| ((*resPairs)[ti].ind2!=jj))) ti++;
-                if (ti<l)
+                if (ti<l) 
                 {
                   if (TEST_OPT_PROT) Print("cc");
@@ -470 +470 @@
   idDelete(&pairs);
 }
-
+ 
 /*3
 * performs the modification of a single reduction on the syzygy-level
@@ -481 +481 @@
   pDelete(&p);
 }
-
+ 
 /*3
 * normalizes the poly bucket by the ideal;
@@ -494 +494 @@
   number n;
   BOOLEAN isChanged=FALSE;
-
+ 
   loop
   {
@@ -511 +511 @@
   return isChanged;
 }
-
+ 
 /*3
 * a tail reduction for the syzygies yielding new generators
@@ -521 +521 @@
   poly h,hn;
   BOOLEAN dummy;
-
+ 
   while ((i>0) && (red->m[i-1]==NULL)) i--;
   i--;
@@ -570 +570 @@
   return tored;
 }
-
+ 
 /*3
 * the complete reduction of a single pair which is just stored
-* in bucket and syz_bucket
+* in bucket and syz_bucket 
 */
 static BOOLEAN syRedSyzPair(syStrategy syzstr,int index,int* g_l,int* orp_l)
@@ -583 +583 @@
   number n;
   BOOLEAN isChanged=FALSE;
-
+ 
   loop
   {
@@ -601 +601 @@
   return isChanged;
 }
-
+ 
 /*3
 * the tailreduction for generators (which includes the correction of
@@ -612 +612 @@
   poly h,hn;
   BOOLEAN dummy;
-
+ 
   h = tso.p;
   kBucketInit(syzstr->syz_bucket,tso.syz,*syzred_l);
@@ -642 +642 @@
   assume(pLength(tso.p)==*tored_l);
 }
-
+ 
 /*3
 * the reduction of a pair in the 0-th module
 */
-static void redOnePair(SSet resPairs,int itso,int l, ideal syzygies,
+static void redOnePair(SSet resPairs,int itso,int l, ideal syzygies, 
             int crit_comp, syStrategy syzstr,int index,ideal new_generators,
             ideal new_repr,int * ogm_l,int * orp_l)
@@ -665 +665 @@
 #endif
   int syz_place=IDELEMS(syzygies);
-
+ 
   while ((syz_place>0) && (syzygies->m[syz_place-1]==NULL)) syz_place--;
   while ((ng_place>0) && (new_generators->m[ng_place-1]==NULL)) ng_place--;
@@ -690 +690 @@
 #ifdef EXPERIMENT3
 /*--- tests wether the product criterion applies --------------*/
-    if ((index==0) && (old_generators->rank==1) &&
+    if ((index==0) && (old_generators->rank==1) && 
         (pFDeg(tso.p1)+pFDeg(tso.p2)==tso.order))
     {
@@ -753 +753 @@
       tso.syz = pAdd(p,tso.syz);
 #ifdef EXPERIMENT2
-      if ((tso.syz!=NULL) && (pGetComp(tso.syz)<=crit_comp))
+      if ((tso.syz!=NULL) && (pGetComp(tso.syz)<=crit_comp)) 
       {
 /*--- breaks when the leading component is less than crit_comp ------*/
@@ -778 +778 @@
       loop
       {
-        if (j>=og_idel)
+        if (j>=og_idel) 
         {
 /*--- reduction with generators computed in this procedure ---*/
@@ -795 +795 @@
             break;
           }
-          //if (syzp==NULL)
+          //if (syzp==NULL) 
             //assume(p==NULL);
-          //else
+          //else 
             //if (pGetComp(syzp)<=crit_comp) short_pairs++;
 #endif
@@ -817 +817 @@
             deleteP =TRUE;
           }
-          //if (syzp==NULL)
+          //if (syzp==NULL) 
             //assume(p==NULL);
-          //else
+          //else 
             //if ((pGetComp(syzp)<=crit_comp) && (p!=NULL)) short_pairs++;
 #endif
@@ -861 +861 @@
     for (i=itso+1;i<l;i++)
     {
-      if (resPairs[i].lcm!=NULL)
-      {
+      if (resPairs[i].lcm!=NULL) 
+      { 
         if ((resPairs[i].ind1==toReplace-1)||(resPairs[i].ind2==toReplace-1))
           syDeletePair(&resPairs[i]);
-        else
+        else 
         {
           if (resPairs[i].ind1>=toReplace)
@@ -930 +930 @@
   syTestPairs(resPairs,l,old_generators);
 }
-
+ 
 /*3
 * reduction of all pairs of a fixed degree of the 0-th module
@@ -943 +943 @@
   int * orp_l=(int*)omAlloc0(IDELEMS(syzstr->orderedRes[index])*sizeof(int));
   int t1=IDELEMS(syzstr->res[index]),t2=IDELEMS(syzstr->orderedRes[index]);
-
-  for (j=IDELEMS(syzstr->res[index])-1;j>=0;j--)
+ 
+  for (j=IDELEMS(syzstr->res[index])-1;j>=0;j--) 
   {
     if (syzstr->res[index]->m[j]!=NULL)
       ogm_l[j] = pLength(syzstr->res[index]->m[j]);
   }
-  for (j=IDELEMS(syzstr->orderedRes[index])-1;j>=0;j--)
+  for (j=IDELEMS(syzstr->orderedRes[index])-1;j>=0;j--) 
   {
     if (syzstr->orderedRes[index]->m[j]!=NULL)
@@ -986 +986 @@
   return FALSE;
 }
-
+ 
 /*3
 * extends the standard basis old_generators with new_generators;
@@ -992 +992 @@
 * assumes that the components of the new_generators are sperated
 * from those of old_generators, i.e. whenever the leading term
-* of a syzygy lies in the part of the old_generators, the syzygy
-* lie just in the module old_generators
+* of a syzygy lies in the part of the old_generators, the syzygy 
+* lie just in the module old_generators 
 * assumes that the new_generators are reduced w.r.t. old_generators
 */
@@ -1002 +1002 @@
   int l_pairs=2*og_idel;
   ideal syzygies=idInit(16,syzstr->res[index]->rank+1);
-  ideal result;
   if ((idIs0(new_generators)) || (new_generators->m[0]==NULL))
   {
     Werror("Hier ist was faul!\n");
-    return result;
+    return NULL;
   }
   SSet resPairs=(SSet)omAlloc0(l_pairs*sizeof(SObject));
@@ -1019 +1018 @@
   return syzygies;
 }
-
+ 
 /*3
 * normalizes the incoming generators
@@ -1030 +1029 @@
   poly p = kBucketGetLm(syzstr->bucket),result;
   number n;
-
+ 
   loop
   {
@@ -1047 +1046 @@
   return result;
 }
-
+ 
 /*3
 * updates the pairs inthe higher modules
@@ -1060 +1059 @@
   poly p=NULL;
   SObject tso;
-
+ 
   syInitializePair(&tso);
   while ((l>0) && ((*resPairs)[l-1].lcm==NULL)) l--;
@@ -1099 +1098 @@
                 int ti=0;
                 while ((ti<l) && (((*resPairs)[ti].ind1!=j1)|| ((*resPairs)[ti].ind2!=j))) ti++;
-                if (ti<l)
+                if (ti<l) 
                 {
                   if (TEST_OPT_PROT) Print("cc");
@@ -1171 +1170 @@
   idDelete(&pairs);
 }
-
+ 
 /*3
 * reduction of a single pair in the higher moduls
 */
-static void redOnePairHIndex(SSet resPairs,int itso, int crit_comp,
+static void redOnePairHIndex(SSet resPairs,int itso, int crit_comp, 
             syStrategy syzstr,int index,ideal add_generators, ideal add_repr,
             ideal new_generators, ideal new_repr,int * next_place_add,int ** g_l,
@@ -1190 +1189 @@
   poly syzp;
 #endif
-
+ 
   assume (tso.ind1<*next_place_add);
   assume (tso.ind2<*next_place_add);
@@ -1363 +1362 @@
   syDeletePair(&resPairs[itso]);
 }
-
+ 
 /*3
 * reduction of all pairs of a fixed degree of a fixed module
@@ -1375 +1374 @@
   int i=0,j;
   poly deg_soc;
-
+ 
   if (TEST_OPT_PROT)
     Print("(%d,%d)",index,resPairs[0].order);
@@ -1395 +1394 @@
   return TRUE;
 }
-
+ 
 /*3
 * we proceed the generators of the next module;
 * they are stored in add_generators and add_repr;
-* if the normal form of a new genrators w.r.t. add_generators has
+* if the normal form of a new genrators w.r.t. add_generators has 
 * pGetComp<crit_comp it is skipped from the reduction;
-* new_generators and new_repr (which are empty) stores the result of the
+* new_generators and new_repr (which are empty) stores the result of the 
 * reduction which is normalized afterwards
 */
@@ -1418 +1417 @@
   BOOLEAN pairs_left;
   SSet resPairs=(SSet)omAlloc0(l_pairs*sizeof(SObject));
-
+ 
   for (j=IDELEMS(syzstr->res[index])-1;j>=0;j--)
   {
@@ -1437 +1436 @@
     if (syzstr->regularity>0)
     {
-      if (next_deg >= syzstr->regularity+index)
+      if (next_deg >= syzstr->regularity+index) 
       {
         while ((i<idel_temp) && (temp_generators->m[i]!=NULL))
@@ -1471 +1470 @@
             pEnlargeSet(&add_generators->m,IDELEMS(add_generators),16);
             pEnlargeSet(&add_repr->m,IDELEMS(add_repr),16);
-            gen_length = (int*)omRealloc0Size((ADDRESS)gen_length, IDELEMS(add_generators)*sizeof(int),
+            gen_length = (int*)omRealloc0Size((ADDRESS)gen_length, IDELEMS(add_generators)*sizeof(int), 
                                         (IDELEMS(add_generators)+16)*sizeof(int));
             IDELEMS(add_generators) += 16;
@@ -1530 +1529 @@
   omFreeSize((ADDRESS)secgen_length,IDELEMS(syzstr->res[index])*sizeof(int));
 }
-
+ 
 /*3
 * normalizes the part of the next reduction lying within the block
@@ -1544 +1543 @@
   number n;
   int * g_l=(int*)omAlloc0(IDELEMS(old_generators)*sizeof(int));
-
+ 
   for (i=0;i<IDELEMS(old_generators);i++)
   {
@@ -1552 +1551 @@
     }
   }
-  for (i=IDELEMS(new_generators)-1;i>=0;i--)
+  for (i=IDELEMS(new_generators)-1;i>=0;i--) 
   {
     if (new_generators->m[i]!=NULL)
@@ -1564 +1563 @@
       {
         if ((j>=ii) || (p==NULL)) break;
-        if ((old_generators->m[j]!=NULL) &&
+        if ((old_generators->m[j]!=NULL) && 
             (pDivisibleBy(old_generators->m[j],p)))
         {
@@ -1592 +1591 @@
   return result;
 }
-
+ 
 /*3
 * constructs the new subresolution for a nonregular extension
@@ -1664 +1663 @@
   return normalizeOldPart(new_generators,new_repr,syzstr,index,next_comp);
 }
-
+ 
 /*
 * this procedure assumes that the first order is C !!!
@@ -1693 +1692 @@
   int ng_idel=IDELEMS(new_generators);
   ideal new_repr =idInit(ng_idel, crit_comp+ng_idel);
-
+ 
   if (index==0)
   {
@@ -1752 +1751 @@
   return result;
 }
-
+ 
 /*
 * main call of the extended Koszul-resolution
@@ -1765 +1764 @@
   tHomog hom=isNotHomog;
   BOOLEAN isRegular;
-
+ 
   discard_pairs = 0;
   short_pairs = 0;
@@ -1922 +1921 @@
         new_generators = temp_gens;
 #ifdef ONLY_STD
-        break;
+        break; 
 #endif
         if (idIs0(new_generators)) break;

Singular/tok.h

@@ -7 +7 @@
 * ABSTRACT: tokens, types for interpreter; general macros
 */
-/* $Id: tok.h,v 1.51 2001-08-27 14:47:44 Singular Exp $ */
+/* $Id: tok.h,v 1.52 2002-01-30 14:33:07 Singular Exp $ */
 
 #ifndef MYYSTYPE
@@ -119 +119 @@
   RESERVEDNAME_CMD,
   RESULTANT_CMD,
-  RINGLIST_CMD,
   ROWS_CMD,
   SIMPLEX_CMD,
@@ -157 +156 @@
 */
 
-#define Sy_bit(x)     (1<<(x))
+#define Sy_bit(x)     ((unsigned)1<<(x))
 #define Sy_inset(x,s) ((Sy_bit(x)&(s))?TRUE:FALSE)
 #define BTEST1(a)     Sy_inset((a), test)
@@ -205 +204 @@
 #define OPT_WEIGHTM       31
 
-/* define ring dependent options */
+/* define ring dependent options */ 
 #define TEST_RINGDEP_OPTS \
  (Sy_bit(OPT_INTSTRATEGY) | Sy_bit(OPT_REDTHROUGH) | Sy_bit(OPT_REDTAIL))