Changeset f93c5e9 in git

Timestamp:

Feb 29, 2012, 7:49:42 PM (11 years ago)

Author:

Hans Schoenemann <hannes@…>

Branches:

(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', 'a800fe4b3e9d37a38c5a10cc0ae9dfa0c15a4ee6')

Children:

ece1ce5f2a8a9e000496d4f95d697f07df0551e6

Parents:

8d8cd944663cf80b3fd163a42279526ce163a5fd

Message:

add: new order am: weights on vars and gens

Files:

• Singular/ipshell.cc (modified) (5 diffs)
• libpolys/polys/monomials/p_polys.cc (modified) (30 diffs)
• libpolys/polys/monomials/ring.cc (modified) (31 diffs)
• libpolys/polys/monomials/ring.h (modified) (4 diffs)

Singular/ipshell.cc

@@ -1863 +1863 @@
       iv=new intvec(1);
       (*iv)[0] = s;
-    } else
-    if (r->block1[i]-r->block0[i] >=0 )
-    {
-      j=r->block1[i]-r->block0[i];
-      if (r->order[i]==ringorder_M)  j=(j+1)*(j+1)-1;
+    }
+    else if (r->block1[i]-r->block0[i] >=0 )
+    {
+      int bl=j=r->block1[i]-r->block0[i];
+      if (r->order[i]==ringorder_M)
+      {
+        j=(j+1)*(j+1)-1;
+        bl=j+1;
+      }
+      else if (r->order[i]==ringorder_am)
+      {
+        j+=r->wvhdl[i][bl+1];
+      }
       iv=new intvec(j+1);
       if ((r->wvhdl!=NULL) && (r->wvhdl[i]!=NULL))
       {
-        for(;j>=0; j--) (*iv)[j]=r->wvhdl[i][j];
+        for(;j>=0; j--) (*iv)[j]=r->wvhdl[i][j+(j>bl)];
       }
       else switch (r->order[i])
@@ -4460 +4468 @@
 
   uResultant::resMatType mtype= determineMType( imtype );
-  int i,c,count;
+  int i,count;
   lists listofroots= NULL;
   number smv= NULL;
@@ -4517 +4525 @@
 
 #ifdef mprDEBUG_PROT
-  c= iproots[0]->getAnzElems();
+  int c= iproots[0]->getAnzElems();
   for (i=0; i < c; i++) pWrite(iproots[i]->getPoly());
   c= muiproots[0]->getAnzElems();
@@ -4661 +4669 @@
     }
     else if (((*iv)[1]!=ringorder_a)
-    && ((*iv)[1]!=ringorder_a64))
+    && ((*iv)[1]!=ringorder_a64)
+    && ((*iv)[1]!=ringorder_am))
       o++;
     n++;
@@ -4805 +4814 @@
             break;
           }
+          case ringorder_am:
+          {
+            R->block0[n] = last+1;
+            R->block1[n] = si_min(last+iv->length()-2 , rVar(R));
+            R->wvhdl[n] = (int*)omAlloc(iv->length()*sizeof(int));
+            if (R->block1[n]- R->block0[n]+2>=iv->length())
+               WarnS("missing module weights");
+            for (i=2; i<=(R->block1[n]-R->block0[n]+2); i++)
+            {
+              R->wvhdl[n][i-2]=(*iv)[i];
+              last++;
+              if (weights[last]==0) weights[last]=(*iv)[i]*typ;
+            }
+            R->wvhdl[n][i-2]=iv->length() -3 -(R->block1[n]- R->block0[n]);
+            for (; i<iv->length(); i++)
+            {
+              R->wvhdl[n][i-1]=(*iv)[i];
+            }
+            last=R->block0[n]-1;
+            break;
+          }
           case ringorder_a64:
           {

libpolys/polys/monomials/p_polys.cc

@@ -7 +7 @@
  *  Author:  obachman (Olaf Bachmann)
  *  Created: 8/00
- *  Version: $Id$
  *******************************************************************/
 
@@ -119 +118 @@
 #endif
           p->exp[o->data.wp.place]=ord;
+          break;
+        }
+        case ro_am:
+        {
+          ord=POLY_NEGWEIGHT_OFFSET;
+          int a,e;
+          a=o->data.am.start;
+          e=o->data.am.end;
+          int *w=o->data.am.weights;
+#if 1
+          for(int i=a;i<=e;i++) ord+=p_GetExp(p,i,r)*w[i-a];
+          int c=p_GetComp(p,r);
+#else
+          long ai;
+          int ei,wi;
+          for(int i=a;i<=e;i++)
+          {
+             ei=p_GetExp(p,i,r);
+             wi=w[i-a];
+             ai=ei*wi;
+             if (ai/ei!=wi) pSetm_error=TRUE;
+             ord+=ai;
+             if (ord<ai) pSetm_error=TRUE;
+          }
+#endif
+          if ((c>0)&&(c<=o->data.am.len_gen))
+          {
+            ord+=w[c-(e-a)+2];
+          }
+          p->exp[o->data.am.place]=ord;
           break;
         }
@@ -205 +234 @@
           const short place = o->data.syz.place;
           const int limit = o->data.syz.limit;
-          
+
           if (c > limit)
             p->exp[place] = o->data.syz.curr_index;
@@ -319 +348 @@
 #ifndef NDEBUG
 #if MYTEST
-            Print("Respective F[c - %d: %d] pp: ", limit, c); 
+            Print("Respective F[c - %d: %d] pp: ", limit, c);
             p_DebugPrint(pp, r, r, 1);
 #endif
@@ -329 +358 @@
 
 
-//        const int st = o->data.isTemp.start;       
+//          const int st = o->data.isTemp.start;
 
 #ifndef NDEBUG
@@ -372 +401 @@
           {
             p->exp[start] = 0; //!!!!????? where?????
-             
+
             const int* const pVarOffset = o->data.is.pVarOffset;
 
@@ -488 +517 @@
   p_LmCheckPolyRing(p, r);
   int i, k;
-  int pIS = 0; 
+  int pIS = 0;
   long j =0;
 
@@ -551 +580 @@
           break;
 
-        // only prefix adds the weight... 
+        // only prefix adds the weight...
 
         if( (k = p_GetComp(p, r)) == 0 )
@@ -557 +586 @@
 
         const int ord_pos = rGetISPos(pIS++, r);
-        
+
         const intvec* componentWeights = r->typ[ord_pos].data.is.componentWeights;
 
         if( componentWeights == NULL )
           break;
-              
+
         const int limit = r->typ[ord_pos].data.is.limit;
         assume( limit >= 0 );
-        
+
         if( k > limit )
         {
           k -= (limit + 1);
           assume( k >= 0 );
-          
+
           assume( componentWeights != NULL );
-          
+
           if( k < componentWeights->length() )
             j += (*componentWeights)[k]; // j += the weight of k^th-component
@@ -623 +652 @@
         const int limit = r->typ[pos].data.is.limit;
         assume( limit >= 0 );
-        
+
 
         if( k > limit )
@@ -1560 +1589 @@
   assume(divisor != NULL);
   if (p == NULL) return NULL;
-  
+
   poly result = NULL;
   number divisorLC = p_GetCoeff(divisor, r);
@@ -1634 +1663 @@
 {
   assume((p != NULL) || (q != NULL));
-  
+
   poly a = p; poly b = q;
   if (p_Deg(a, r) < p_Deg(b, r)) { a = q; b = p; }
@@ -1678 +1707 @@
 poly p_ExtGcd(poly p, poly &pFactor, poly q, poly &qFactor, ring r)
 {
-  assume((p != NULL) || (q != NULL));  
+  assume((p != NULL) || (q != NULL));
   poly a = p; poly b = q; BOOLEAN aCorrespondsToP = TRUE;
   if (p_Deg(a, r) < p_Deg(b, r))
@@ -2228 +2257 @@
   }
 
-   
+
   poly p=ph;
   number h=d;
@@ -3405 +3434 @@
 
 /*2
- * returns a re-ordered convertion of a number as a polynomial, 
+ * returns a re-ordered convertion of a number as a polynomial,
  * with permutation of parameters
  * NOTE: this only works for Frank's alg. & trans. fields
@@ -3421 +3450 @@
     n_Delete(&zz, src->cf);
   }
-   
+
   PrintS("\nDestination Ring: \n");
   rWrite(dst);
-   
+
   Print("\nOldPar: %d\n", OldPar);
   for( int i = 1; i <= OldPar; i++ )
@@ -3433 +3462 @@
   if( z == NULL )
      return NULL;
-   
+
   const coeffs srcCf = src->cf;
   assume( srcCf != NULL );
@@ -3439 +3468 @@
   assume( !nCoeff_is_GF(srcCf) );
   assume( rField_is_Extension(src) );
-   
+
   poly zz = NULL;
-   
+
   const ring srcExtRing = srcCf->extRing;
   assume( srcExtRing != NULL );
-   
+
   const coeffs dstCf = dst->cf;
   assume( dstCf != NULL );
@@ -3454 +3483 @@
     if( zz == NULL )
        return NULL;
-     
-  } else if (nCoeff_is_transExt(srcCf)) 
-  {   
+
+  } else if (nCoeff_is_transExt(srcCf))
+  {
     assume( !IS0(z) );
-     
+
     zz = NUM(z);
     p_Test (zz, srcExtRing);
-     
+
     if( zz == NULL )
        return NULL;
-     
+
     if( !DENIS1(z) )
       WarnS("Not implemented yet: Cannot permute a rational fraction and make a polynomial out of it! Ignorring the denumerator.");
   } else
      {
-        assume (FALSE);
-        Werror("Number permutation is not implemented for this data yet!");
-        return NULL;
+        assume (FALSE);
+        Werror("Number permutation is not implemented for this data yet!");
+        return NULL;
      }
-   
+
   assume( zz != NULL );
   p_Test (zz, srcExtRing);
 
-  
+
   nMapFunc nMap = n_SetMap(srcExtRing->cf, dstCf);
-     
+
   assume( nMap != NULL );
-     
+
   poly qq = p_PermPoly(zz, par_perm - 1, srcExtRing, dst, nMap, NULL, rVar(srcExtRing) );
 //       poly p_PermPoly (poly p, int * perm, const ring oldRing, const ring dst, nMapFunc nMap, int *par_perm, int OldPar)
-   
+
 //  assume( FALSE );  WarnS("longalg missing 2");
-     
+
   return qq;
 }
@@ -3501 +3530 @@
     PrintS("\np_PermPoly::p: "); p_Write(p, oldRing, oldRing); PrintLn();
 #endif
-  
+
   const int OldpVariables = rVar(oldRing);
   poly result = NULL;
@@ -3516 +3545 @@
       assume( nMap != NULL );
       number n = nMap(p_GetCoeff(p, oldRing), oldRing->cf, dst->cf);
-       
+
       if ( (!rMinpolyIsNULL(dst)) && (rField_is_Zp_a(dst) || rField_is_Q_a(dst)) )
         n_Normalize(n, dst->cf);
-       
+
       p_GetCoeff(qq, dst) = n;
-      // coef may be zero:  
+      // coef may be zero:
       p_Test(qq, dst);
     }
     else
     {
-      qq = p_One(dst);       
+      qq = p_One(dst);
 
 //      aq = naPermNumber(p_GetCoeff(p, oldRing), par_perm, OldPar, oldRing); // no dst???
@@ -3533 +3562 @@
 
       p_Test(aq, dst);
-       
+
       if ( (!rMinpolyIsNULL(dst)) && (rField_is_Zp_a(dst) || rField_is_Q_a(dst)) )
       {
         p_Normalize(aq,dst);
-         
+
       }
       if (aq == NULL)
-        p_SetCoeff(qq, n_Init(0, dst->cf),dst); // Very dirty trick!!!
-         
+        p_SetCoeff(qq, n_Init(0, dst->cf),dst); // Very dirty trick!!!
+
       p_Test(aq, dst);
     }
-     
-    if (rRing_has_Comp(dst)) 
+
+    if (rRing_has_Comp(dst))
        p_SetComp(qq, p_GetComp(p, oldRing), dst);
 
@@ -3552 +3581 @@
       p_LmDelete(&qq,dst);
       qq = NULL;
-    }     
+    }
     else
     {
@@ -3571 +3600 @@
             if (rField_is_GF(dst))
             {
-              assume( dst->cf->extRing == NULL );
+               assume( dst->cf->extRing == NULL );
               number ee = nfPar(1, dst->cf); // NOTE: using nfPar is a BAD thing to do...
 
-              number eee;
-              n_Power(ee, e, &eee, dst->cf); //nfDelete(ee,dst);
-               
+              number eee;
+              n_Power(ee, e, &eee, dst->cf); //nfDelete(ee,dst);
+
               ee = n_Mult(c, eee, dst->cf);
               //nfDelete(c,dst);nfDelete(eee,dst);
@@ -3583 +3612 @@
             else if (nCoeff_is_Extension(dst->cf))
             {
-              const int par = -perm[i];
-              assume( par > 0 );
+              const int par = -perm[i];
+              assume( par > 0 );
 
 //              WarnS("longalg missing 3");
 #if 1
-              const coeffs C = dst->cf;
-              assume( C != NULL );
-              
-              const ring R = C->extRing;
-              assume( R != NULL );
-               
-              assume( par <= rVar(R) );
-               
-              poly pcn; // = (number)c
-              
-              assume( !n_IsZero(c, C) );
-               
-              if( nCoeff_is_algExt(C) )
-                 pcn = (poly) c;
-               else //            nCoeff_is_transExt(C)
-                 pcn = NUM(c);
-              
+              const coeffs C = dst->cf;
+              assume( C != NULL );
+
+              const ring R = C->extRing;
+              assume( R != NULL );
+
+              assume( par <= rVar(R) );
+
+              poly pcn; // = (number)c
+
+              assume( !n_IsZero(c, C) );
+
+              if( nCoeff_is_algExt(C) )
+                 pcn = (poly) c;
+               else //            nCoeff_is_transExt(C)
+                 pcn = NUM(c);
+
               if (pNext(pcn) == NULL) // c->z
                 p_AddExp(pcn, -perm[i], e, R);
@@ -3612 +3641 @@
                 p_SetExp(mmc, -perm[i], e, R);
                 p_Setm(mmc, R);
-                 
-                number nnc;
-                // convert back to a number: number nnc = mmc; 
-                if( nCoeff_is_algExt(C) ) 
-                   nnc = (number) mmc;
-                else //            nCoeff_is_transExt(C)
-                  nnc = ntInit(mmc, C);
-                
+
+                number nnc;
+                // convert back to a number: number nnc = mmc;
+                if( nCoeff_is_algExt(C) )
+                   nnc = (number) mmc;
+                else //            nCoeff_is_transExt(C)
+                  nnc = ntInit(mmc, C);
+
                 p_GetCoeff(qq, dst) = n_Mult((number)c, nnc, C);
                 n_Delete((number *)&c, C);
                 n_Delete((number *)&nnc, C);
               }
-               
+
               mapped_to_par=1;
 #endif
@@ -3645 +3674 @@
     }
     pIter(p);
-     
+
 #if 0
     p_Test(aq,dst);
     PrintS("\naq: "); p_Write(aq, dst, dst); PrintLn();
 #endif
-     
+
 
 #if 1
@@ -3656 +3685 @@
     {
       p_Setm(qq,dst);
-       
+
       p_Test(aq,dst);
       p_Test(qq,dst);
-       
+
 #if 0
     p_Test(qq,dst);
     PrintS("\nqq: "); p_Write(qq, dst, dst); PrintLn();
 #endif
-       
-      if (aq!=NULL) 
-         qq=p_Mult_q(aq,qq,dst);
-       
+
+      if (aq!=NULL)
+         qq=p_Mult_q(aq,qq,dst);
+
       aq = qq;
-       
+
       while (pNext(aq) != NULL) pIter(aq);
-       
+
       if (result_last==NULL)
       {
@@ -3688 +3717 @@
     }
   }
-   
+
   result=p_SortAdd(result,dst);
 #else
@@ -3719 +3748 @@
 #endif
   p_Test(result,dst);
-   
+
 #if 0
   p_Test(result,dst);

libpolys/polys/monomials/ring.cc

@@ -73 +73 @@
   "ws", ///< ringorder_ws,
   "Ws", ///< ringorder_Ws,
+  "am",  ///< ringorder_am,
   "L", ///< ringorder_L,
   "aa", ///< ringorder_aa
@@ -321 +322 @@
     ||(r->order[l] == ringorder_M)
     ||(r->order[l] == ringorder_a)
+    ||(r->order[l] == ringorder_am)
     ||(r->order[l] == ringorder_a64)
     ||(r->order[l] == ringorder_aa) ) && (r->order[l] < ringorder_IS) )
@@ -355 +357 @@
         if (r->order[l]!=ringorder_M) break;
       }
+      if (r->order[l]==ringorder_am) /*j==0*/
+      {
+        int m=r->wvhdl[l][i];
+        Print("\n//                  : %d module weights ",m);
+        m+=i;i++;
+        for(;i<=m;i++) Print(" %*d" ,nlen,r->wvhdl[l][i]);
+      }
     }
   }
@@ -381 +390 @@
     } else
       PrintS(" ...");
-     
+
 #if 0  /*Singularg should not differ from Singular except in error case*/
     Print("\n//   noncommutative type:%d", (int)ncRingType(r));
@@ -412 +421 @@
     if( details )
     {
-      PrintLn();       
+      PrintLn();
       iiWriteMatrix((matrix)r->qideal,"_",1,r);
     } else PrintS(" ...");
@@ -1150 +1159 @@
 
       nMapFunc nMap1 = n_SetMap(R1->cf,sum->cf); /* can change something global: not usable
-                                                    after the next nSetMap call :( */
+                                                    after the next nSetMap call :( */
       // Create blocked C and D matrices:
       for (i=1; i<= rVar(R1); i++)
@@ -1167 +1176 @@
 
       nMapFunc nMap2 = n_SetMap(R2->cf,sum->cf); /* can change something global: not usable
-                                                    after the next nSetMap call :( */
+                                                    after the next nSetMap call :( */
       for (i=1; i<= rVar(R2); i++)
         for (j=i+1; j<=rVar(R2); j++)
@@ -1376 +1385 @@
   if (r->extRing!=NULL)
     r->extRing->ref++;
-  
-  res->extRing=r->extRing;  
+
+  res->extRing=r->extRing;
   //memset: res->minideal=NULL;
 */
-  
-  
+
+
   if (copy_ordering == TRUE)
   {
@@ -1520 +1529 @@
   if (r->extRing!=NULL)
     r->extRing->ref++;
-  
-  res->extRing=r->extRing;  
+
+  res->extRing=r->extRing;
   //memset: res->minideal=NULL;
 */
-  
-  
+
+
   if (copy_ordering == TRUE)
   {
@@ -1678 +1687 @@
     if ( rMinpolyIsNULL(r2) ) return FALSE;
     if (! p_EqualPolys(r1->cf->extRing->minideal->m[0],
-                  r2->cf->extRing->minideal->m[0], 
-                  r1->cf->extRing))
+                  r2->cf->extRing->minideal->m[0],
+                  r1->cf->extRing))
       return FALSE;
   }
@@ -2193 +2202 @@
     }
   }
+}
+
+static void rO_WMDegree(int &place, int &bitplace, int start, int end,
+    long *o, sro_ord &ord_struct, int *weights)
+{
+  // weighted degree (aligned) of variables v_start..v_end, ordsgn 1
+  while((start<end) && (weights[0]==0)) { start++; weights++; }
+  while((start<end) && (weights[end-start]==0)) { end--; }
+  rO_Align(place,bitplace);
+  ord_struct.ord_typ=ro_am;
+  ord_struct.data.am.start=start;
+  ord_struct.data.am.end=end;
+  ord_struct.data.am.place=place;
+  ord_struct.data.am.len_gen=weights[end-start+1];
+  ord_struct.data.am.weights=weights;
+  o[place]=1;
+  place++;
+  rO_Align(place,bitplace);
 }
 
@@ -3039 +3066 @@
     case ringorder_a:
     case ringorder_aa:
+    case ringorder_am:
     case ringorder_a64:
       if (r->OrdSgn==-1) r->MixedOrder=TRUE;
@@ -3151 +3179 @@
   int** wvhdl = r->wvhdl;
 
-  
-
   if (order[0]==ringorder_S ||order[0]==ringorder_s || order[0]==ringorder_IS)
   {
@@ -3166 +3192 @@
   r->pLDeg = (r->OrdSgn == 1 ? pLDegb : pLDeg0);
 
+  /*======== ordering type is (am,_) ==================*/
+  if ((order[0]==ringorder_am)
+  )
+  {
+    r->MixedOrder = FALSE;
+    for(int ii=block0[0];ii<=block1[0];ii++)
+      if (wvhdl[0][ii-1]<0) { r->MixedOrder=TRUE;break;}
+    r->LexOrder=FALSE;
+    for(int ii=block0[0];ii<=block1[0];ii++)
+      if (wvhdl[0][ii-1]==0) { r->LexOrder=TRUE;break;}
+    if ((block0[0]==1)&&(block1[0]==r->N))
+    {
+      r->pFDeg = p_Deg;
+      r->pLDeg = pLDeg1c_Deg;
+    }
+    else
+   {
+      r->pFDeg = p_WTotaldegree;
+      r->LexOrder=TRUE;
+      r->pLDeg = pLDeg1c_WFirstTotalDegree;
+    }
+    r->firstwv = wvhdl[0];
+  }
   /*======== ordering type is (_,c) =========================*/
-  if ((order[0]==ringorder_unspec) || (order[1] == 0)
+  else if ((order[0]==ringorder_unspec) || (order[1] == 0)
       ||(
     ((order[1]==ringorder_c)||(order[1]==ringorder_C)
@@ -3272 +3321 @@
       r->pFDeg = p_TotaldegreeIS;
     }
-#ifndef NDEBUG    
+#ifndef NDEBUG
     else
       assume( r->pFDeg == p_Deg || r->pFDeg == p_WTotaldegree );
 #endif
-    
+
     r->pLDeg = pLDeg1;
   }
@@ -3405 +3454 @@
       case ringorder_aa:
         rO_WDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,tmp_typ[typ_i],
+                   r->wvhdl[i]);
+        typ_i++;
+        break;
+
+      case ringorder_am:
+        rO_WMDegree(j,j_bits,r->block0[i],r->block1[i],tmp_ordsgn,tmp_typ[typ_i],
                    r->wvhdl[i]);
         typ_i++;
@@ -3543 +3598 @@
                                      tmp_typ[typ_i]);
              typ_i++;
-             rCheckOrdSgn(r,i);
+             rCheckOrdSgn(r,i);
           }
         }
@@ -3569 +3624 @@
                                      tmp_typ[typ_i]);
              typ_i++;
-             rCheckOrdSgn(r,i);
+             rCheckOrdSgn(r,i);
           }
         }
@@ -3588 +3643 @@
                          tmp_ordsgn, v,bits, r->block0[i]);
         }
-        rCheckOrdSgn(r,i);
+        rCheckOrdSgn(r,i);
         break;
 
@@ -3600 +3655 @@
                      tmp_ordsgn,v, bits, r->block1[i]);
         }
-        rCheckOrdSgn(r,i);
+        rCheckOrdSgn(r,i);
         break;
 
@@ -3956 +4011 @@
   }
   // corresponds to ro_typ from ring.h:
-  const char *TYP[]={"ro_dp","ro_wp","ro_wp64","ro_wp_neg","ro_cp",
+  const char *TYP[]={"ro_dp","ro_wp","ro_am","ro_wp64","ro_wp_neg","ro_cp",
                      "ro_syzcomp", "ro_syz", "ro_isTemp", "ro_is", "ro_none"};
   int i,j;
@@ -4027 +4082 @@
       }
     }
+    else if  (r->typ[j].ord_typ==ro_am)
+    {
+      Print("  place %d",r->typ[j].data.am.place);
+      Print("  start %d",r->typ[j].data.am.start);
+      Print("  end %d",r->typ[j].data.am.end);
+      Print("  len_gen %d",r->typ[j].data.am.len_gen);
+      PrintS(" w:");
+      int l=0;
+      for(l=r->typ[j].data.am.start;l<=r->typ[j].data.am.end;l++)
+            Print(" %d",r->typ[j].data.am.weights[l-r->typ[j].data.am.start]);
+      l=r->typ[j].data.am.end+1;
+      int ll=r->typ[j].data.am.weights[l-r->typ[j].data.am.start];
+      PrintS(" m:");
+      for(int lll=l+1;lll<l+ll+1;lll++)
+            Print(" %d",r->typ[j].data.am.weights[lll-r->typ[j].data.am.start]);
+    }
     else
     {
@@ -4114 +4185 @@
       pFDeg_CASE(p_TotaldegreeIS); else
 #undef pFDeg_CASE
-      
       Print("(%p)", (void*)(r->pFDeg)); // default case
 
     PrintLn();
-    Print("pLDeg   : (%p)", (void*)(r->pLDeg));    
+    Print("pLDeg   : (%p)", (void*)(r->pLDeg));
     PrintLn();
   }
-
+  Print("pSetm:");
+  void p_Setm_Dummy(poly p, const ring r);
+  void p_Setm_TotalDegree(poly p, const ring r);
+  void p_Setm_WFirstTotalDegree(poly p, const ring r);
+  void p_Setm_General(poly p, const ring r);
+  if (r->p_Setm==p_Setm_General) PrintS("p_Setm_General\n");
+  else if (r->p_Setm==p_Setm_Dummy) PrintS("p_Setm_Dummy\n");
+  else if (r->p_Setm==p_Setm_TotalDegree) PrintS("p_Setm_Totaldegree\n");
+  else if (r->p_Setm==p_Setm_WFirstTotalDegree) PrintS("p_Setm_WFirstTotalDegree\n");
+  else Print("%x\n",r->p_Setm);
 }
 
@@ -4593 +4672 @@
 {
   rTest(r);
-   
+
   ring new_r_1 = rAssure_CompLastBlock(r, FALSE); // due to this FALSE - no completion!
   ring new_r = rAssure_SyzComp(new_r_1, FALSE); // new_r_1 is used only here!!!
@@ -4599 +4678 @@
   if (new_r == r)
      return r;
-     
+
   ring old_r = r;
   if (new_r_1 != new_r && new_r_1 != old_r) rDelete(new_r_1);
-     
+
    rComplete(new_r, 1);
 #ifdef HAVE_PLURAL
@@ -4610 +4689 @@
        {
 # ifndef NDEBUG
-          WarnS("error in nc_rComplete"); // cleanup?      rDelete(res);       return r;  // just go on...?
+          WarnS("error in nc_rComplete"); // cleanup?      rDelete(res);       return r;  // just go on...?
 # endif
        }
    }
 #endif
-     
+
 ///?    rChangeCurrRing(new_r);
    if (old_r->qideal != NULL)
@@ -4628 +4707 @@
        {
 #ifndef NDEBUG
-          WarnS("error in nc_SetupQuotient"); // cleanup?      rDelete(res);       return r;  // just go on...?
+          WarnS("error in nc_SetupQuotient"); // cleanup?      rDelete(res);       return r;  // just go on...?
 #endif
        }
@@ -4639 +4718 @@
    assume(ncRingType(new_r) == ncRingType(old_r));
 #endif
-   
+
    rTest(new_r);
    rTest(old_r);
@@ -5579 +5658 @@
 
   const BOOLEAN ret = nCoeff_is_algExt(C);
-  
+
   if( ret )
   {
@@ -5586 +5665 @@
     assume( !idIs0(R->minideal) );
   }
-  
+
   return ret;
 }
@@ -5614 +5693 @@
   if( _filed_type == n_algExt )
     return naParam(iParameter, C);
-  
+
   if( _filed_type == n_transExt )
     return ntParam(iParameter, C);
-    
+
   return NULL;
 }

libpolys/polys/monomials/ring.h

@@ -55 +55 @@
   ro_dp, // ordering is a degree ordering
   ro_wp, // ordering is a weighted degree ordering
+  ro_am, // ordering is am: weights for vars + weights for gen
   ro_wp64, // ordering is a weighted64 degree ordering
   ro_wp_neg, // ordering is a weighted degree ordering
@@ -86 +87 @@
 
 // ordering is a weighted degree ordering
+struct sro_am
+{
+  short place;  // where weighted degree is stored (in L)
+  short start;  // bounds of ordering (in E)
+  short end;
+  short len_gen; // i>len_gen: weight(gen(i)):=0
+  int *weights; // pointers into wvhdl field of length (end-start+1) + len_gen
+                // contents w_1,... w_n, len, mod_w_1, .. mod_w_len, 0
+};
+typedef struct sro_am sro_am;
+
+// ordering is a weighted degree ordering
 struct sro_wp64
 {
@@ -166 +179 @@
      sro_dp dp;
      sro_wp wp;
+     sro_am am;
      sro_wp64 wp64;
      sro_cp cp;
@@ -600 +614 @@
   ringorder_ws,
   ringorder_Ws,
+  ringorder_am,
   ringorder_L,
   // the following are only used internally