Changeset 6ccdd3a in git

Timestamp:

May 26, 2011, 4:42:12 PM (12 years ago)

Author:

Frank Seelisch <seelisch@…>

Branches:

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

Children:

7af488ec51790060979537b35a03fb345e053f90

Parents:

5a4b26f3e00776270c3ba83b16c92a69f3cca0e0

git-author:

Frank Seelisch <seelisch@mathematik.uni-kl.de>2011-05-26 16:42:12+02:00

git-committer:

Mohamed Barakat <mohamed.barakat@rwth-aachen.de>2011-11-09 12:39:06+01:00

Message:

renamed algring; comments; transext.* added

Files:

• Singular/extra.cc (modified) (1 diff)
• Singular/iparith.cc (modified) (1 diff)
• Singular/ipassign.cc (modified) (1 diff)
• Singular/ipshell.cc (modified) (2 diffs)
• Singular/maps_ip.cc (modified) (3 diffs)
• Singular/mpsr_PutPoly.cc (modified) (3 diffs)
• Singular/walk.cc (modified) (2 diffs)
• kernel/structs.h (modified) (1 diff)
• kernel/walkSupport.cc (modified) (1 diff)
• libpolys/coeffs/coeffs.h (modified) (1 diff)
• libpolys/polys/OBSOLETE_pInitContent.cc (modified) (6 diffs)
• libpolys/polys/clapconv.cc (modified) (8 diffs)
• libpolys/polys/clapsing.cc (modified) (12 diffs)
• libpolys/polys/ext_fields/algext.cc (modified) (14 diffs)
• libpolys/polys/ext_fields/algext.h (modified) (5 diffs)
• libpolys/polys/ext_fields/longalg.cc (modified) (12 diffs)
• libpolys/polys/ext_fields/longtrans.cc (modified) (20 diffs)
• libpolys/polys/ext_fields/longtrans.h (modified) (1 diff)
• libpolys/polys/ext_fields/transext.cc (added)
• libpolys/polys/ext_fields/transext.h (added)
• libpolys/polys/monomials/p_polys.cc (modified) (7 diffs)
• libpolys/polys/monomials/ring.cc (modified) (4 diffs)
• libpolys/polys/monomials/ring.h (modified) (2 diffs)
• libpolys/tests/polys_test.h (modified) (7 diffs)

Singular/extra.cc

@@ -3497 +3497 @@
         new_ring->P=lev;
         new_ring->parameter=names;
-        new_ring->algring=alg_ring;
+        new_ring->extRing=alg_ring;
         new_ring->ch=1;
         rComplete(new_ring,TRUE);

Singular/iparith.cc

@@ -5986 +5986 @@
     if (rField_is_Extension(currRing))
     {
-      assume(currRing->algring!=NULL);
+      assume(currRing->extRing!=NULL);
       lnumber n=(lnumber)pGetCoeff(p);
-      ringvar=-p_Var(n->z,currRing->algring);
+      ringvar=-p_Var(n->z,currRing->extRing);
     }
     if(ringvar==0)

Singular/ipassign.cc

@@ -182 +182 @@
     currRing->minpoly=p;
     naMinimalPoly=((lnumber)currRing->minpoly)->z;
-    if (p_GetExp(((lnumber)currRing->minpoly)->z,1,currRing->algring)==0)
+    if (p_GetExp(((lnumber)currRing->minpoly)->z,1,currRing->extRing)==0)
     {
       Werror("minpoly must not be constant");

Singular/ipshell.cc

@@ -1757 +1757 @@
   else if (rIsExtension(r))
   {
-    if (r->algring!=NULL)
-      rDecomposeCF(&(L->m[0]),r->algring,r);
+    if (r->extRing!=NULL)
+      rDecomposeCF(&(L->m[0]),r->extRing,r);
     else
     {
@@ -2311 +2311 @@
       if (is_gf_char==-1)
       {
-        R->algring=rCompose((lists)L->m[0].Data());
-        if (R->algring==NULL)
+        R->extRing=rCompose((lists)L->m[0].Data());
+        if (R->extRing==NULL)
         {
           WerrorS("could not create rational function coefficient field");
           goto rCompose_err;
         }
-        if (R->algring->ch>0)
-          R->ch= -R->algring->ch;
+        if (R->extRing->ch>0)
+          R->ch= -R->extRing->ch;
         else
           R->ch=1;
-        R->P=R->algring->N;
+        R->P=R->extRing->N;
         R->parameter=(char**)omAlloc0(R->P*sizeof(char_ptr));
         int i;
         for(i=R->P-1;i>=0;i--)
-          R->parameter[i]=omStrDup(R->algring->names[i]);
-        if (R->algring->qideal!=NULL)
+          R->parameter[i]=omStrDup(R->extRing->names[i]);
+        if (R->extRing->qideal!=NULL)
         {
-          if (IDELEMS(R->algring->qideal)==1)
+          if (IDELEMS(R->extRing->qideal)==1)
           {
             R->minpoly=naInit(1,R);
             lnumber n=(lnumber)R->minpoly;
-            n->z=R->algring->qideal->m[0];
+            n->z=R->extRing->qideal->m[0];
             naMinimalPoly=n->z;
-            R->algring->qideal->m[0]=NULL;
-            idDelete(&(R->algring->qideal));
+            R->extRing->qideal->m[0]=NULL;
+            idDelete(&(R->extRing->qideal));
             //redefineFunctionPointers();
           }

Singular/maps_ip.cc

@@ -204 +204 @@
 {
   ideal theMapI=idInit(rPar(currRing),1);
-  nMapFunc nMap=nSetMap(currRing->algring);
+  nMapFunc nMap=nSetMap(currRing->extRing);
 
   int i;
@@ -214 +214 @@
       pp=theMapI->m[i-1]=pOne();
       lnumber n=(lnumber)pGetCoeff(pp);
-      p_SetExp(n->z,i,1,currRing->algring);
-      p_Setm(n->z,currRing->algring);
+      p_SetExp(n->z,i,1,currRing->extRing);
+      p_Setm(n->z,currRing->extRing);
     }
     else
@@ -235 +235 @@
     tmpW.data=n->z;
     if (n->n!=NULL) WarnS("ignoring denominators of coefficients...");
-    if (maApplyFetch(MAP_CMD,theMap,v,&tmpW,currRing->algring,NULL,NULL,0,nMap))
+    if (maApplyFetch(MAP_CMD,theMap,v,&tmpW,currRing->extRing,NULL,NULL,0,nMap))
     {
       WerrorS("map failed");

Singular/mpsr_PutPoly.cc

@@ -196 +196 @@
     mp_failr(IMP_PutUint32(link, 1));
     mp_failr(IMP_PutUint32(link, GetPlength(b->z)));
-    return PutAlgPoly(link, b->z, CurrPutRing->algring);
+    return PutAlgPoly(link, b->z, CurrPutRing->extRing);
   }
   else
@@ -203 +203 @@
     mp_failr(IMP_PutUint32(link, 2));
     mp_failr(IMP_PutUint32(link, GetPlength(b->z)));
-    failr(PutAlgPoly(link, b->z, CurrPutRing->algring));
+    failr(PutAlgPoly(link, b->z, CurrPutRing->extRing));
     mp_failr(IMP_PutUint32(link, GetPlength(b->n)));
-    return PutAlgPoly(link, b->n, CurrPutRing->algring);
+    return PutAlgPoly(link, b->n, CurrPutRing->extRing);
   }
 }
@@ -419 +419 @@
     // alg numbers
     // create temporary ring for describing the coeeficient domain
-    ring alg_r = r->algring;
+    ring alg_r = r->extRing;
     alg_r->minpoly = r->minpoly;
 

Singular/walk.cc

@@ -1950 +1950 @@
   res->VarOffset = NULL;
   res->ref=0;
-  if (currRing->algring!=NULL)
-    currRing->algring->ref++;
+  if (currRing->extRing!=NULL)
+    currRing->extRing->ref++;
 
   if (currRing->parameter!=NULL)
@@ -2029 +2029 @@
   r->VarOffset = NULL;
   r->ref=0;
-  if (currRing->algring!=NULL)
-    currRing->algring->ref++;
+  if (currRing->extRing!=NULL)
+    currRing->extRing->ref++;
 
   if (currRing->parameter!=NULL)

kernel/structs.h

@@ -582 +582 @@
   p_SetmProc    p_Setm;
   n_Procs_s*    cf;
-  ring          algring;
+  ring          extRing;
 #ifdef HAVE_PLURAL
   private:

kernel/walkSupport.cc

@@ -1030 +1030 @@
   res->VarOffset = NULL;
   res->ref=0;
-  if (r->algring!=NULL)
-    r->algring->ref++;
+  if (r->extRing!=NULL)
+    r->extRing->ref++;
   if (r->parameter!=NULL)
   {

libpolys/coeffs/coeffs.h

@@ -180 +180 @@
   /* for extension fields we need to be able to represent polynomials,
      so here is the polynomial ring: */
-  ring          algring;
+  ring          extRing;
 
   //number     minpoly;  //< no longer needed: replaced by
-  //                     //<  algring->minideal->[0]
+  //                     //< extRing->minideal->[0]
 
 

libpolys/polys/OBSOLETE_pInitContent.cc

@@ -107 +107 @@
         while (c_n!=NULL)
         { // each monom: coeff in Q
-          d=nlLcm(hzz,pGetCoeff(c_n),r->algring);
-          n_Delete(&hzz,r->algring);
+          d=nlLcm(hzz,pGetCoeff(c_n),r->extRing);
+          n_Delete(&hzz,r->extRing);
           hzz=d;
           pIter(c_n);
@@ -115 +115 @@
         while (c_n!=NULL)
         { // each monom: coeff in Q
-          d=nlLcm(h,pGetCoeff(c_n),r->algring);
-          n_Delete(&h,r->algring);
+          d=nlLcm(h,pGetCoeff(c_n),r->extRing);
+          n_Delete(&h,r->extRing);
           h=d;
           pIter(c_n);
@@ -127 +127 @@
       number hzztmp=nlInvers(hzz);
       number hh=nlMult(hzz,h);
-      nlDelete(&hzz,r->algring);
-      nlDelete(&h,r->algring);
-      number hg=nlGcd(hzztmp,htmp,r->algring);
-      nlDelete(&hzztmp,r->algring);
-      nlDelete(&htmp,r->algring);
+      nlDelete(&hzz,r->extRing);
+      nlDelete(&h,r->extRing);
+      number hg=nlGcd(hzztmp,htmp,r->extRing);
+      nlDelete(&hzztmp,r->extRing);
+      nlDelete(&htmp,r->extRing);
       h=nlMult(hh,hg);
-      nlDelete(&hg,r->algring);
-      nlDelete(&hh,r->algring);
+      nlDelete(&hg,r->extRing);
+      nlDelete(&hh,r->extRing);
       nlNormalize(h);
       if(!nlIsOne(h))
@@ -147 +147 @@
             d=nlMult(h,pGetCoeff(c_n));
             nlNormalize(d);
-            nlDelete(&pGetCoeff(c_n),r->algring);
+            nlDelete(&pGetCoeff(c_n),r->extRing);
             pGetCoeff(c_n)=d;
             pIter(c_n);
@@ -156 +156 @@
             d=nlMult(h,pGetCoeff(c_n));
             nlNormalize(d);
-            nlDelete(&pGetCoeff(c_n),r->algring);
+            nlDelete(&pGetCoeff(c_n),r->extRing);
             pGetCoeff(c_n)=d;
             pIter(c_n);
@@ -163 +163 @@
         }
       }
-      nlDelete(&h,r->algring);
+      nlDelete(&h,r->extRing);
     }
   }

libpolys/polys/clapconv.cc

@@ -169 +169 @@
       for ( i = rVar(r); i>0 ; i-- )
         p_SetExp( term, i , exp[i+var_start],r);
-      //if (rRing_has_Comp(currRing->algring)) p_SetComp(term, 0, currRing->algring); // done by pInit
+      //if (rRing_has_Comp(currRing->extRing)) p_SetComp(term, 0, currRing->extRing); // done by pInit
       if (par_start==0)
       {
         for ( i = 1; i <= var_start; i++ )
         //z->e[i-1]+=exp[i];
-          p_AddExp(z,i,exp[i],r->algring);
+          p_AddExp(z,i,exp[i],r->extRing);
       }
       else
@@ -180 +180 @@
         for ( i = par_start+1; i <= var_start+rPar(currRing); i++ )
         //z->e[i-1]+=exp[i];
-          p_AddExp(z,i,exp[i-par_start],r->algring);
+          p_AddExp(z,i,exp[i-par_start],r->extRing);
       }
       pGetCoeff(term)=(number)ALLOC0_LNUMBER();
@@ -226 +226 @@
       }
     }
-    if ( (e = p_GetExp( p, 1, r->algring )) != 0 )
+    if ( (e = p_GetExp( p, 1, r->extRing )) != 0 )
       term *= power( a , e );
     result += term;
@@ -237 +237 @@
 {
   if ( f.isImm() )
-    return n_Init( f.intval(), r->algring );
+    return n_Init( f.intval(), r->extRing );
   else
   {
@@ -271 +271 @@
     // pNext( t ) = NULL; //already done by napNew
     pGetCoeff(t)=convFactoryNSingAN( i.coeff(), r );
-    if (n_IsZero(napGetCoeff(t),r->algring))
-    {
-      p_Delete(&t,r->algring);
+    if (n_IsZero(napGetCoeff(t),r->extRing))
+    {
+      p_Delete(&t,r->extRing);
     }
     else
     {
-      p_SetExp(t,1,i.exp(),r->algring);
-      a=p_Add_q(a,t,r->algring);
+      p_SetExp(t,1,i.exp(),r->extRing);
+      a=p_Add_q(a,t,r->extRing);
     }
   }
@@ -286 +286 @@
     {
       lnumber l=(lnumber)r->minpoly;
-      if (p_GetExp(a,1,r->algring) >= p_GetExp(l->z,1,r->algring))
+      if (p_GetExp(a,1,r->extRing) >= p_GetExp(l->z,1,r->extRing))
         a = napRemainder( a, l->z);
     }
@@ -302 +302 @@
   {
     n_Normalize(pGetCoeff(p),r);
-    CanonicalForm term=convSingPFactoryP(((lnumber)pGetCoeff(p))->z,r->algring);
+    CanonicalForm term=convSingPFactoryP(((lnumber)pGetCoeff(p))->z,r->extRing);
 
     if ((((lnumber)pGetCoeff(p))->n!=NULL)
@@ -353 +353 @@
       p_SetExp( term, i ,exp[i], r);
     //if (rRing_has_Comp(currRing)) p_SetComp(term, 0, currRing); // done by pInit
-    pGetCoeff(term)=(number)ALLOC0_LNUMBER();
-    ((lnumber)pGetCoeff(term))->z=convFactoryPSingP( f, r->algring );
+    pGetCoeff(term)=(number)omAlloc0Bin(rnumber_bin);
+    ((lnumber)pGetCoeff(term))->z=convFactoryPSingP( f, r->extRing );
     p_Setm( term,r );
     result = p_Add_q( result, term,r );

libpolys/polys/clapsing.cc

@@ -281 +281 @@
       pIter(p);
     }
-    g = convSingPFactoryP( ((lnumber)g1)->z, r->cf->algring );
-    g = gcd( g, convSingPFactoryP( ((lnumber)g2)->z , r->cf->algring));
+    g = convSingPFactoryP( ((lnumber)g1)->z, r->cf->extRing );
+    g = gcd( g, convSingPFactoryP( ((lnumber)g2)->z , r->cf->extRing));
 
     // second run: gcd's
@@ -289 +289 @@
     while ( (p != NULL) && (g != 1)  && ( g != 0))
     {
-      h = convSingPFactoryP( ((lnumber)pGetCoeff(p))->z, r->cf->algring );
+      h = convSingPFactoryP( ((lnumber)pGetCoeff(p))->z, r->cf->extRing );
       pIter( p );
 
@@ -307 +307 @@
       {
         lnumber c=(lnumber)pGetCoeff(p);
-        p_Delete(&c->z,r->cf->algring); // 2nd arg used to be nacRing
-        c->z=convFactoryPSingP( i.getItem() / g, r->cf->algring );
+        p_Delete(&c->z,r->cf->extRing); // 2nd arg used to be nacRing
+        c->z=convFactoryPSingP( i.getItem() / g, r->cf->extRing );
         //nTest((number)c);
         //#ifdef LDEBUG
@@ -514 +514 @@
   else if (rField_is_Extension(r))
   {
-    if (r->cf->algring->minideal!=NULL)
-    {
-      CanonicalForm mipo=convSingPFactoryP(r->cf->algring->minideal->m[0],
-                                           r->cf->algring);
+    if (r->cf->extRing->minideal!=NULL)
+    {
+      CanonicalForm mipo=convSingPFactoryP(r->cf->extRing->minideal->m[0],
+                                           r->cf->extRing);
       Variable a=rootOf(mipo);
       CanonicalForm F( convSingPFactoryP( f,r ) );
@@ -576 +576 @@
         intvec *w=NULL;
         if (v!=NULL) w=*v;
-        if (r->cf->algring->minideal==NULL)
+        if (r->cf->extRing->minideal==NULL)
         {
           if(!count_Factors(res,w,j,ff,convFactoryPSingP( J.getItem().factor(),r ),r))
@@ -708 +708 @@
     }
   }
-  if (rField_is_Q_a(r) && (r->cf->algring->minideal!=NULL))
+  if (rField_is_Q_a(r) && (r->cf->extRing->minideal!=NULL))
   {
     int i=IDELEMS(res)-1;
@@ -1228 +1228 @@
  {
    CanonicalForm mipo=convSingPFactoryP(((lnumber)currRing->minpoly)->z,
-                                         currRing->algring);
+                                         currRing->extRing);
    Variable a=rootOf(mipo);
    CanonicalForm F( convSingAFactoryA( f,a, currRing ) ),
@@ -1242 +1242 @@
  else
  {
-   CanonicalForm F( convSingPFactoryP( f,currRing->algring ) ),
-                 G( convSingPFactoryP( g,currRing->algring ) );
+   CanonicalForm F( convSingPFactoryP( f,currRing->extRing ) ),
+                 G( convSingPFactoryP( g,currRing->extRing ) );
    CanonicalForm GCD;
    // calculate gcd
@@ -1249 +1249 @@
 
    // calculate lcm
-   res= convFactoryPSingP( (F/GCD)*G, currRing->algring );
+   res= convFactoryPSingP( (F/GCD)*G, currRing->extRing );
  }
 
@@ -1267 +1267 @@
  {
    CanonicalForm mipo=convSingPFactoryP(((lnumber)currRing->minpoly)->z,
-                         currRing->algring);
+                         currRing->extRing);
    Variable a=rootOf(mipo);
    CanonicalForm F( convSingAFactoryA( f,a, currRing ) ),
@@ -1283 +1283 @@
  else
  {
-   CanonicalForm F( convSingPFactoryP( f,currRing->algring ) ),
-                 G( convSingPFactoryP( g,currRing->algring ) );
+   CanonicalForm F( convSingPFactoryP( f,currRing->extRing ) ),
+                 G( convSingPFactoryP( g,currRing->extRing ) );
    CanonicalForm GCD;
 
@@ -1291 +1291 @@
    if ((GCD!=1) && (GCD!=0))
    {
-     ff= convFactoryPSingP( F/ GCD, currRing->algring );
-     gg= convFactoryPSingP( G/ GCD, currRing->algring );
+     ff= convFactoryPSingP( F/ GCD, currRing->extRing );
+     gg= convFactoryPSingP( G/ GCD, currRing->extRing );
    }
  }

libpolys/polys/ext_fields/algext.cc

@@ -4 +4 @@
 /* $Id$ */
 /*
-* ABSTRACT: numbers in an algebraic extension field K(a)
+* ABSTRACT: numbers in an algebraic extension field K[a] / < f(a) >
 *           Assuming that we have a coeffs object cf, then these numbers
 *           are polynomials in the polynomial ring K[a] represented by
-*           cf->algring.
+*           cf->extRing.
 *           IMPORTANT ASSUMPTIONS:
-*           1.) So far we assume that cf->algring is a valid polynomial
+*           1.) So far we assume that cf->extRing is a valid polynomial
 *               ring in exactly one variable, i.e., K[a], where K is allowed
 *               to be any field (representable in SINGULAR and which may
@@ -15 +15 @@
 *               towers).
 *           2.) Moreover, this implementation assumes that
-*               cf->algring->minideal is not NULL but an ideal with at
+*               cf->extRing->minideal is not NULL but an ideal with at
 *               least one non-zero generator which may be accessed by
-*               cf->algring->minideal->m[0] and which represents the minimal
-*               polynomial of the extension variable 'a' in K[a].
+*               cf->extRing->minideal->m[0] and which represents the minimal
+*               polynomial f(a) of the extension variable 'a' in K[a].
+*           3.) As soon as an std method for polynomial rings becomes
+*               availabe, all reduction steps modulo f(a) should be replaced
+*               by a call to std. Moreover, in this situation one can finally
+*               move from K[a] / < f(a) > to
+*                  K[a_1, ..., a_s] / I, with I some zero-dimensional ideal
+*                                        in K[a_1, ..., a_s] given by a lex
+*                                        Gröbner basis.
+*               The code in algext.h and algext.cc is then capable of
+*               computing in K[a_1, ..., a_s] / I.
 */
 
@@ -98 +107 @@
   while (nCoeff_is_Extension(cf))
   {
-    assume(cf->algring != NULL); assume(cf->algring->cf != NULL);
-    cf = cf->algring->cf;
+    assume(cf->extRing != NULL); assume(cf->extRing->cf != NULL);
+    cf = cf->extRing->cf;
     height++;
   }
@@ -229 +238 @@
   Print("//   with the minimal polynomial f(%s) = %s\n", x,
         p_String(naMinpoly, naRing));
-  PrintS("//   and K: "); n_CoeffWrite(cf->algring->cf);
+  PrintS("//   and K: "); n_CoeffWrite(cf->extRing->cf);
 }
 
@@ -379 +388 @@
     /* basically, just write aAsPoly using p_Write,
        but use brackets around the output, if a is not
-       a constant living in naCoeffs = cf->algring->cf */
+       a constant living in naCoeffs = cf->extRing->cf */
     BOOLEAN useBrackets = !(p_IsConstant(aAsPoly, naRing));
     if (useBrackets) StringAppendS("(");
@@ -409 +418 @@
 }
 
-/* expects *param to be castable to ExtInfo */
+/* expects *param to be castable to AlgExtInfo */
 static BOOLEAN naCoeffIsEqual(const coeffs cf, n_coeffType n, void * param)
 {
   if (naID != n) return FALSE;
-  ExtInfo *e = (ExtInfo *)param;
+  AlgExtInfo *e = (AlgExtInfo *)param;
   /* for extension coefficient fields we expect the underlying
      polynomials rings to be IDENTICAL, i.e. the SAME OBJECT;
@@ -487 +496 @@
 number naMap00(number a, const coeffs src, const coeffs dst)
 {
-  assume(src == dst->algring->cf);
-  poly result = p_One(dst->algring);
-  p_SetCoeff(result, naCopy(a, src), dst->algring);
+  assume(src == dst->extRing->cf);
+  poly result = p_One(dst->extRing);
+  p_SetCoeff(result, naCopy(a, src), dst->extRing);
   return (number)result;
 }
@@ -498 +507 @@
   /* mapping via intermediate int: */
   int n = n_Int(a, src);
-  number q = n_Init(n, dst->algring->cf);
-  poly result = p_One(dst->algring);
-  p_SetCoeff(result, q, dst->algring);
+  number q = n_Init(n, dst->extRing->cf);
+  poly result = p_One(dst->extRing);
+  p_SetCoeff(result, q, dst->extRing);
   return (number)result;
 }
@@ -514 +523 @@
 number naMap0P(number a, const coeffs src, const coeffs dst)
 {
-  int p = rChar(dst->algring);
+  int p = rChar(dst->extRing);
   int n = nlModP(a, p, src);
-  number q = n_Init(n, dst->algring->cf);
-  poly result = p_One(dst->algring);
-  p_SetCoeff(result, q, dst->algring);
+  number q = n_Init(n, dst->extRing->cf);
+  poly result = p_One(dst->extRing);
+  p_SetCoeff(result, q, dst->extRing);
   return (number)result;
 }
@@ -525 +534 @@
 number naMapPP(number a, const coeffs src, const coeffs dst)
 {
-  assume(src == dst->algring->cf);
-  poly result = p_One(dst->algring);
-  p_SetCoeff(result, naCopy(a, src), dst->algring);
+  assume(src == dst->extRing->cf);
+  poly result = p_One(dst->extRing);
+  p_SetCoeff(result, naCopy(a, src), dst->extRing);
   return (number)result;
 }
@@ -536 +545 @@
   /* mapping via intermediate int: */
   int n = n_Int(a, src);
-  number q = n_Init(n, dst->algring->cf);
-  poly result = p_One(dst->algring);
-  p_SetCoeff(result, q, dst->algring);
+  number q = n_Init(n, dst->extRing->cf);
+  poly result = p_One(dst->extRing);
+  p_SetCoeff(result, q, dst->extRing);
   return (number)result;
 }
@@ -576 +585 @@
   if (nCoeff_is_Q(bSrc) && nCoeff_is_Q(bDst))
   {
-    if (strcmp(rParameter(src->algring)[0],
-               rParameter(dst->algring)[0]) == 0)
+    if (strcmp(rParameter(src->extRing)[0],
+               rParameter(dst->extRing)[0]) == 0)
       return naCopyMap;                                  /// Q(a)   --> Q(a)
     else
@@ -585 +594 @@
   if (nCoeff_is_Zp(bSrc) && nCoeff_is_Zp(bDst))
   {
-    if (strcmp(rParameter(src->algring)[0],
-               rParameter(dst->algring)[0]) == 0)
+    if (strcmp(rParameter(src->extRing)[0],
+               rParameter(dst->extRing)[0]) == 0)
       return naCopyMap;                                  /// Z/p(a) --> Z/p(a)
     else
@@ -599 +608 @@
   assume( getCoeffType(cf) == naID );
   
-  ExtInfo *e = (ExtInfo *)infoStruct;
-  /// first check whether cf->algring != NULL and delete old ring???
-  cf->algring           = e->r;
-  cf->algring->minideal = e->i;
-
-  assume(cf->algring                     != NULL);      // algring;
-  assume((cf->algring->minideal          != NULL) &&    // minideal has one
-         (IDELEMS(cf->algring->minideal) != 0)    &&    // non-zero generator
-         (cf->algring->minideal->m[0]    != NULL)    ); // at m[0];
-  assume(cf->algring->cf                 != NULL);      // algring->cf;
+  AlgExtInfo *e = (AlgExtInfo *)infoStruct;
+  /// first check whether cf->extRing != NULL and delete old ring???
+  cf->extRing           = e->r;
+  cf->extRing->minideal = e->i;
+
+  assume(cf->extRing                     != NULL);      // extRing;
+  assume((cf->extRing->minideal          != NULL) &&    // minideal has one
+         (IDELEMS(cf->extRing->minideal) != 0)    &&    // non-zero generator
+         (cf->extRing->minideal->m[0]    != NULL)    ); // at m[0];
+  assume(cf->extRing->cf                 != NULL);      // extRing->cf;
   assume(getCoeffType(cf) == naID);                     // coeff type;
   
   /* propagate characteristic up so that it becomes
      directly accessible in cf: */
-  cf->ch = cf->algring->cf->ch;
+  cf->ch = cf->extRing->cf->ch;
   
   #ifdef LDEBUG

libpolys/polys/ext_fields/algext.h

@@ -6 +6 @@
 /* $Id$ */
 /*
-* ABSTRACT: numbers in an algebraic extension field K(a)
+* ABSTRACT: numbers in an algebraic extension field K[a] / < f(a) >
 *           Assuming that we have a coeffs object cf, then these numbers
 *           are polynomials in the polynomial ring K[a] represented by
-*           cf->algring.
+*           cf->extRing.
 *           IMPORTANT ASSUMPTIONS:
-*           1.) So far we assume that cf->algring is a valid polynomial
+*           1.) So far we assume that cf->extRing is a valid polynomial
 *               ring in exactly one variable, i.e., K[a], where K is allowed
 *               to be any field (representable in SINGULAR and which may
@@ -17 +17 @@
 *               towers).
 *           2.) Moreover, this implementation assumes that
-*               cf->algring->minideal is not NULL but an ideal with at
+*               cf->extRing->minideal is not NULL but an ideal with at
 *               least one non-zero generator which may be accessed by
-*               cf->algring->minideal->m[0] and which represents the minimal
-*               polynomial of the extension variable 'a' in K[a].
+*               cf->extRing->minideal->m[0] and which represents the minimal
+*               polynomial f(a) of the extension variable 'a' in K[a].
+*           3.) As soon as an std method for polynomial rings becomes
+*               availabe, all reduction steps modulo f(a) should be replaced
+*               by a call to std. Moreover, in this situation one can finally
+*               move from K[a] / < f(a) > to
+*                  K[a_1, ..., a_s] / I, with I some zero-dimensional ideal
+*                                        in K[a_1, ..., a_s] given by a lex
+*                                        Gröbner basis.
+*               The code in algext.h and algext.cc is then capable of
+*               computing in K[a_1, ..., a_s] / I.
 */
+
 #include <coeffs/coeffs.h>
 
@@ -30 +40 @@
 typedef struct sip_sideal * ideal;
 
-/// struct for pass initialization parameters to naInitChar
-typedef struct 
-{
-  ring r;
-  ideal i;
-} ExtInfo;
+/// struct for passing initialization parameters to naInitChar
+typedef struct { ring r; ideal i; } AlgExtInfo;
 
 /// Get a mapping function from src into the domain of this type (n_algExt)
@@ -87 +93 @@
 
 /* polynomial ring in which our numbers live */
-#define naRing cf->algring
+#define naRing cf->extRing
 
 /* coeffs object in which the coefficients of our numbers live;
@@ -93 +99 @@
  * coefficients of our numbers, e.g., use naCoeffs->nAdd to add
  * coefficients of our numbers */
-#define naCoeffs cf->algring->cf
+#define naCoeffs cf->extRing->cf
 
 /* minimal polynomial */

libpolys/polys/ext_fields/longalg.cc

@@ -174 +174 @@
   else if (i < 0)
   {
-    naIsChar0 = 0;
-    npSetChar(-i, r->algring); // to be changed HS
+    ntIsChar0 = 0;
+    npSetChar(-i, r->extRing); // to be changed HS
   }
 #ifdef TEST
@@ -183 +183 @@
   }
 #endif
-  nacRing        = r->algring;
+  nacRing        = r->extRing;
   nacInit        = nacRing->cf->cfInit;
   nacInt         = nacRing->cf->n_Int;
@@ -950 +950 @@
   if (i!=0)
   {
-    number c=n_Init(i,r->algring);
-    if (!n_IsZero(c,r->algring))
-    {
-      poly z=p_Init(r->algring);
+    number c=n_Init(i,r->extRing);
+    if (!n_IsZero(c,r->extRing))
+    {
+      poly z=p_Init(r->extRing);
       pSetCoeff0(z,c);
       lnumber l = (lnumber)omAllocBin(rnumber_bin);
@@ -1007 +1007 @@
 {
   lnumber l=(lnumber)n;
-  if ((l!=NULL)&&(l->n==NULL)&&(p_IsConstant(l->z,r->algring)))
-  {
-    return nacInt(pGetCoeff(l->z),r->algring);
+  if ((l!=NULL)&&(l->n==NULL)&&(p_IsConstant(l->z,r->extRing)))
+  {
+    return nacInt(pGetCoeff(l->z),r->extRing);
   }
   return 0;
@@ -1023 +1023 @@
     lnumber l = (lnumber) * p;
     if (l==NULL) return;
-    p_Delete(&(l->z),r->algring);
-    p_Delete(&(l->n),r->algring);
+    p_Delete(&(l->z),r->extRing);
+    p_Delete(&(l->n),r->extRing);
     omFreeBin((void *)l,  rnumber_bin);
   }
@@ -1051 +1051 @@
   lnumber src = (lnumber)p;
   erg = (lnumber)omAlloc0Bin(rnumber_bin);
-  erg->z = p_Copy(src->z,r->algring);
-  erg->n = p_Copy(src->n,r->algring);
+  erg->z = p_Copy(src->z,r->extRing);
+  erg->n = p_Copy(src->n,r->extRing);
   erg->s = src->s;
   return (number)erg;
@@ -1715 +1715 @@
   {
     if (pNext(x->z)!=NULL)
-      result->z = p_Copy(x->z, r->algring);
+      result->z = p_Copy(x->z, r->extRing);
     else
       result->z = napGcd0(x->z, y->z);
@@ -1730 +1730 @@
     poly rz=napGcd(x->z, y->z);
     CanonicalForm F, G, R;
-    R=convSingPFactoryP(rz,r->algring);
+    R=convSingPFactoryP(rz,r->extRing);
     p_Normalize(x->z,nacRing);
-    F=convSingPFactoryP(x->z,r->algring)/R;
+    F=convSingPFactoryP(x->z,r->extRing)/R;
     p_Normalize(y->z,nacRing);
-    G=convSingPFactoryP(y->z,r->algring)/R;
+    G=convSingPFactoryP(y->z,r->extRing)/R;
     F = gcd( F, G );
     if (F.isOne())
@@ -1740 +1740 @@
     else
     {
-      p_Delete(&rz,r->algring);
-      result->z=convFactoryPSingP( F*R,r->algring );
+      p_Delete(&rz,r->extRing);
+      result->z=convFactoryPSingP( F*R,r->extRing );
       p_Normalize(result->z,nacRing);
     }
@@ -2117 +2117 @@
   naTest(la);
   naTest(lb);
-  poly x = p_Copy(a->z, r->algring);
+  poly x = p_Copy(a->z, r->extRing);
   number t = napLcm(b->z); // get all denom of b->z
   if (!nacIsOne(t))
@@ -2125 +2125 @@
     while (xx!=NULL)
     {
-      bt = nacGcd(t, pGetCoeff(xx), r->algring);
+      bt = nacGcd(t, pGetCoeff(xx), r->extRing);
       rr = nacMult(t, pGetCoeff(xx));
-      n_Delete(&pGetCoeff(xx),r->algring);
+      n_Delete(&pGetCoeff(xx),r->extRing);
       pGetCoeff(xx) = nacDiv(rr, bt);
       nacNormalize(pGetCoeff(xx));
-      n_Delete(&bt,r->algring);
-      n_Delete(&rr,r->algring);
+      n_Delete(&bt,r->extRing);
+      n_Delete(&rr,r->extRing);
       pIter(xx);
     }
   }
-  n_Delete(&t,r->algring);
+  n_Delete(&t,r->extRing);
   result->z = x;
 #ifdef HAVE_FACTORY
@@ -2141 +2141 @@
   {
     result->z=singclap_alglcm(result->z,b->n);
-    p_Delete(&x,r->algring);
+    p_Delete(&x,r->extRing);
   }
 #endif

libpolys/polys/ext_fields/longtrans.cc

@@ -128 +128 @@
   {
     ntIsChar0 = 0;
-    npSetChar(-i, r->algring); // to be changed HS
+    npSetChar(-i, r->extRing); // to be changed HS
   }
 #ifdef TEST
@@ -136 +136 @@
   }
 #endif
-  nacRing        = r->algring;
+  nacRing        = r->extRing;
   nacInit        = nacRing->cf->cfInit;
   nacInt         = nacRing->cf->n_Int;
@@ -431 +431 @@
 void napWrite(poly p, const BOOLEAN has_denom, const ring r)
 {
-  ring nacring = r->algring;
+  ring nacring = r->extRing;
   if (p == NULL) StringAppendS("0");
   else if (p_LmIsConstant(p, nacring))
@@ -987 +987 @@
                                                      vs. ntSetMap */
   if (currRing->parameter!=NULL)
-    nMap=currRing->algring->cf->cfSetMap(oldRing->algring, nacRing);
+    nMap=currRing->extRing->cf->cfSetMap(oldRing->extRing, nacRing);
   else
-    nMap=currRing->cf->cfSetMap(oldRing->algring, currRing);
+    nMap=currRing->cf->cfSetMap(oldRing->extRing, currRing);
   if (nMap==NULL) return NULL; /* emergency exit only */
   while(za!=NULL)
@@ -1003 +1003 @@
     if (currRing->parameter!=NULL)
     {
-      assume(oldRing->algring!=NULL);
-      pGetCoeff(p)=(number)ALLOC0_LNUMBER();
+      assume(oldRing->extRing!=NULL);
+      pGetCoeff(p)=(number)omAlloc0Bin(rnumber_bin);
       pan=(lnumber)pGetCoeff(p);
       pan->s=2;
@@ -1079 +1079 @@
   if (x->n!=NULL)
   {
-    lnumber rr=ALLOC0_LNUMBER();
-    rr->z=p_Copy(x->n,r->algring);
+    lnumber rr=(lnumber)omAlloc0Bin(rnumber_bin);
+    rr->z=p_Copy(x->n,r->extRing);
     rr->s = 2;
     return (number)rr;
@@ -1090 +1090 @@
 {
   lnumber x=(lnumber)n;
-  lnumber rr=ALLOC0_LNUMBER();
-  rr->z=p_Copy(x->z,r->algring);
+  lnumber rr=(lnumber)omAlloc0Bin(rnumber_bin);
+  rr->z=p_Copy(x->z,r->extRing);
   rr->s = 2;
   return (number)rr;
@@ -1105 +1105 @@
   if (i!=0)
   {
-    number c=n_Init(i,r->algring);
-    if (!n_IsZero(c,r->algring))
-    {
-      poly z=p_Init(r->algring);
+    number c=n_Init(i,r->extRing);
+    if (!n_IsZero(c,r->extRing))
+    {
+      poly z=p_Init(r->extRing);
       pSetCoeff0(z,c);
       lnumber l = (lnumber)ALLOC_LNUMBER();
@@ -1193 +1193 @@
 {
   lnumber l=(lnumber)n;
-  if ((l!=NULL)&&(l->n==NULL)&&(p_IsConstant(l->z,r->algring)))
-  {
-    return nacInt(pGetCoeff(l->z),r->algring);
+  if ((l!=NULL)&&(l->n==NULL)&&(p_IsConstant(l->z,r->extRing)))
+  {
+    return nacInt(pGetCoeff(l->z),r->extRing);
   }
   return 0;
@@ -1209 +1209 @@
     lnumber l = (lnumber) * p;
     if (l==NULL) return;
-    p_Delete(&(l->z),r->algring);
-    p_Delete(&(l->n),r->algring);
-    FREE_LNUMBER(l);
+    p_Delete(&(l->z),r->extRing);
+    p_Delete(&(l->n),r->extRing);
+    omFreeBin((ADDRESS)l,  rnumber_bin);
   }
   *p = NULL;
@@ -1236 +1236 @@
   lnumber erg;
   lnumber src = (lnumber)p;
-  erg = ALLOC_LNUMBER();
-  erg->z = p_Copy(src->z,r->algring);
-  erg->n = p_Copy(src->n,r->algring);
+  erg = (lnumber)omAlloc0Bin(rnumber_bin);
+  erg->z = p_Copy(src->z,r->extRing);
+  erg->n = p_Copy(src->n,r->extRing);
   erg->s = src->s;
   return (number)erg;
@@ -1871 +1871 @@
   poly rz=napGcd(x->z, y->z);
   CanonicalForm F, G, R;
-  R=convSingPFactoryP(rz,r->algring);
+  R=convSingPFactoryP(rz,r->extRing);
   p_Normalize(x->z,nacRing);
-  F=convSingPFactoryP(x->z,r->algring)/R;
+  F=convSingPFactoryP(x->z,r->extRing)/R;
   p_Normalize(y->z,nacRing);
-  G=convSingPFactoryP(y->z,r->algring)/R;
+  G=convSingPFactoryP(y->z,r->extRing)/R;
   F = gcd( F, G );
   if (F.isOne())
@@ -1881 +1881 @@
   else
   {
-    p_Delete(&rz,r->algring);
-    result->z=convFactoryPSingP( F*R,r->algring );
+    p_Delete(&rz,r->extRing);
+    result->z=convFactoryPSingP( F*R,r->extRing );
     p_Normalize(result->z,nacRing);
   }
@@ -2222 +2222 @@
   ntTest(la);
   ntTest(lb);
-  poly x = p_Copy(a->z, r->algring);
+  poly x = p_Copy(a->z, r->extRing);
   number t = napLcm(b->z); // get all denom of b->z
   if (!nacIsOne(t))
@@ -2230 +2230 @@
     while (xx!=NULL)
     {
-      bt = nacGcd(t, pGetCoeff(xx), r->algring);
+      bt = nacGcd(t, pGetCoeff(xx), r->extRing);
       rr = nacMult(t, pGetCoeff(xx));
-      n_Delete(&pGetCoeff(xx),r->algring);
+      n_Delete(&pGetCoeff(xx),r->extRing);
       pGetCoeff(xx) = nacDiv(rr, bt);
       nacNormalize(pGetCoeff(xx));
-      n_Delete(&bt,r->algring);
-      n_Delete(&rr,r->algring);
+      n_Delete(&bt,r->extRing);
+      n_Delete(&rr,r->extRing);
       pIter(xx);
     }
   }
-  n_Delete(&t,r->algring);
+  n_Delete(&t,r->extRing);
   result->z = x;
 #ifdef HAVE_FACTORY
@@ -2246 +2246 @@
   {
     result->z=singclap_alglcm(result->z,b->n);
-    p_Delete(&x,r->algring);
+    p_Delete(&x,r->extRing);
   }
 #endif
@@ -2436 +2436 @@
   nMapFunc nMap=ntSetMap(oldRing,currRing);
   if (currRing->parameter!=NULL)
-    nMap=currRing->algring->cf->cfSetMap(oldRing->algring, nacRing);
+    nMap=currRing->extRing->cf->cfSetMap(oldRing->extRing, nacRing);
   else
-    nMap=currRing->cf->cfSetMap(oldRing->algring, currRing);
+    nMap=currRing->cf->cfSetMap(oldRing->extRing, currRing);
   if (nMap==NULL) return NULL; /* emergency exit only */
   do
@@ -2453 +2453 @@
     if (currRing->parameter!=NULL)
     {
-      assume(oldRing->algring!=NULL);
-      pGetCoeff(p)=(number)ALLOC0_LNUMBER();
+      assume(oldRing->extRing!=NULL);
+      pGetCoeff(p)=(number)omAlloc0Bin(rnumber_bin);
       pan=(lnumber)pGetCoeff(p);
       pan->s=2;
@@ -2524 +2524 @@
   if (x->n!=NULL)
   {
-    lnumber rr=ALLOC0_LNUMBER();
-    rr->z=p_Copy(x->n,r->algring);
+    lnumber rr=(lnumber)omAlloc0Bin(rnumber_bin);
+    rr->z=p_Copy(x->n,r->extRing);
     rr->s = 2;
     return (number)rr;
@@ -2535 +2535 @@
 {
   lnumber x=(lnumber)n;
-  lnumber rr=ALLOC0_LNUMBER();
-  rr->z=p_Copy(x->z,r->algring);
+  lnumber rr=(lnumber)omAlloc0Bin(rnumber_bin);
+  rr->z=p_Copy(x->z,r->extRing);
   rr->s = 2;
   return (number)rr;

libpolys/polys/ext_fields/longtrans.h

@@ -121 +121 @@
 /* for computing with polynomials living in nacRing */
 poly    napPermNumber(number z, int * par_perm, int P, ring r);
-#define napAddExp(p,i,e)       (p_AddExp(p,i,e,currRing->algring))
+#define napAddExp(p,i,e)       (p_AddExp(p,i,e,currRing->extRing))
 #define napLength(p)           pLength(p)
-#define napNeg(p)              (p_Neg(p,currRing->algring))
+#define napNeg(p)              (p_Neg(p,currRing->extRing))
 #define napVariables           naNumbOfPar
 #define napGetCoeff(p)         pGetCoeff(p)
-#define napGetExpFrom(p,i,r)   (p_GetExp(p,i,r->algring))
-#define napSetExp(p,i,e)       (p_SetExp(p,i,e,currRing->algring))
-#define napNew()               (p_Init(currRing->algring))
-#define napAdd(p1,p2)          (p_Add_q(p1,p2,currRing->algring))
-#define napSetm(p)             p_Setm(p,currRing->algring)
+#define napGetExpFrom(p,i,r)   (p_GetExp(p,i,r->extRing))
+#define napSetExp(p,i,e)       (p_SetExp(p,i,e,currRing->extRing))
+#define napNew()               (p_Init(currRing->extRing))
+#define napAdd(p1,p2)          (p_Add_q(p1,p2,currRing->extRing))
+#define napSetm(p)             p_Setm(p,currRing->extRing)
 #define napCopy(p)             p_Copy(p,nacRing)
 #define napSetCoeff(p,n)       {n_Delete(&pGetCoeff(p),nacRing);pGetCoeff(p)=n;}

libpolys/polys/monomials/p_polys.cc

@@ -2067 +2067 @@
         while (c_n!=NULL)
         { // each monom: coeff in Q
-          d=nlLcm(hzz,pGetCoeff(c_n),r->algring->cf);
-          n_Delete(&hzz,r->algring->cf);
+          d=nlLcm(hzz,pGetCoeff(c_n),r->extRing->cf);
+          n_Delete(&hzz,r->extRing->cf);
           hzz=d;
           pIter(c_n);
@@ -2075 +2075 @@
         while (c_n!=NULL)
         { // each monom: coeff in Q
-          d=nlLcm(h,pGetCoeff(c_n),r->algring->cf);
-          n_Delete(&h,r->algring->cf);
+          d=nlLcm(h,pGetCoeff(c_n),r->extRing->cf);
+          n_Delete(&h,r->extRing->cf);
           h=d;
           pIter(c_n);
@@ -2084 +2084 @@
       /* hzz contains the 1/lcm of all denominators in c_n_n->z*/
       /* h contains the 1/lcm of all denominators in c_n_n->n*/
-      number htmp=nlInvers(h,r->algring->cf);
-      number hzztmp=nlInvers(hzz,r->algring->cf);
-      number hh=nlMult(hzz,h,r->algring->cf);
-      nlDelete(&hzz,r->algring->cf);
-      nlDelete(&h,r->algring->cf);
-      number hg=nlGcd(hzztmp,htmp,r->algring->cf);
-      nlDelete(&hzztmp,r->algring->cf);
-      nlDelete(&htmp,r->algring->cf);
-      h=nlMult(hh,hg,r->algring->cf);
-      nlDelete(&hg,r->algring->cf);
-      nlDelete(&hh,r->algring->cf);
-      nlNormalize(h,r->algring->cf);
-      if(!nlIsOne(h,r->algring->cf))
+      number htmp=nlInvers(h,r->extRing->cf);
+      number hzztmp=nlInvers(hzz,r->extRing->cf);
+      number hh=nlMult(hzz,h,r->extRing->cf);
+      nlDelete(&hzz,r->extRing->cf);
+      nlDelete(&h,r->extRing->cf);
+      number hg=nlGcd(hzztmp,htmp,r->extRing->cf);
+      nlDelete(&hzztmp,r->extRing->cf);
+      nlDelete(&htmp,r->extRing->cf);
+      h=nlMult(hh,hg,r->extRing->cf);
+      nlDelete(&hg,r->extRing->cf);
+      nlDelete(&hh,r->extRing->cf);
+      nlNormalize(h,r->extRing->cf);
+      if(!nlIsOne(h,r->extRing->cf))
       {
         p=ph;
@@ -2105 +2105 @@
           while (c_n!=NULL)
           { // each monom: coeff in Q
-            d=nlMult(h,pGetCoeff(c_n),r->algring->cf);
-            nlNormalize(d,r->algring->cf);
-            nlDelete(&pGetCoeff(c_n),r->algring->cf);
+            d=nlMult(h,pGetCoeff(c_n),r->extRing->cf);
+            nlNormalize(d,r->extRing->cf);
+            nlDelete(&pGetCoeff(c_n),r->extRing->cf);
             pGetCoeff(c_n)=d;
             pIter(c_n);
@@ -2114 +2114 @@
           while (c_n!=NULL)
           { // each monom: coeff in Q
-            d=nlMult(h,pGetCoeff(c_n),r->algring->cf);
-            nlNormalize(d,r->algring->cf);
-            nlDelete(&pGetCoeff(c_n),r->algring->cf);
+            d=nlMult(h,pGetCoeff(c_n),r->extRing->cf);
+            nlNormalize(d,r->extRing->cf);
+            nlDelete(&pGetCoeff(c_n),r->extRing->cf);
             pGetCoeff(c_n)=d;
             pIter(c_n);
@@ -2123 +2123 @@
         }
       }
-      nlDelete(&h,r->algring->cf);
+      nlDelete(&h,r->extRing->cf);
       #endif
     }
@@ -3452 +3452 @@
               lnumber c=(lnumber)pGetCoeff(qq);
               if (c->z->next==NULL)
-                p_AddExp(c->z,-perm[i],e/*p_GetExp( p,i,oldRing)*/,dst->algring);
+                p_AddExp(c->z,-perm[i],e/*p_GetExp( p,i,oldRing)*/,dst->extRing);
               else /* more difficult: we have really to multiply: */
               {
                 lnumber mmc=(lnumber)naInit(1,dst);
-                p_SetExp(mmc->z,-perm[i],e/*p_GetExp( p,i,oldRing)*/,dst->algring);
-                p_Setm(mmc->z,dst->algring->cf);
+                p_SetExp(mmc->z,-perm[i],e/*p_GetExp( p,i,oldRing)*/,dst->extRing);
+                p_Setm(mmc->z,dst->extRing->cf);
                 pGetCoeff(qq)=n_Mult((number)c,(number)mmc,dst->cf);
                 n_Delete((number *)&c,dst->cf);

libpolys/polys/monomials/ring.cc

@@ -1388 +1388 @@
 
 /*
-  if (r->algring!=NULL)
-    r->algring->ref++;
+  if (r->extRing!=NULL)
+    r->extRing->ref++;
   
-  res->algring=r->algring;  
+  res->extRing=r->extRing;  
   //memset: res->minideal=NULL;
 */
@@ -1536 +1536 @@
   {
     if ( rMinpolyIsNULL(r2) ) return FALSE;
-    if (! p_EqualPolys(r1->cf->algring->minideal->m[0],
-                  r2->cf->algring->minideal->m[0], 
-                  r1->cf->algring))
+    if (! p_EqualPolys(r1->cf->extRing->minideal->m[0],
+                  r2->cf->extRing->minideal->m[0], 
+                  r1->cf->extRing))
       return FALSE;
   }
@@ -1965 +1965 @@
 
   if (!rMinpolyIsNULL(r))
-    omCheckAddr(r->cf->algring->minideal->m[0]);
+    omCheckAddr(r->cf->extRing->minideal->m[0]);
 
   //assume(r->cf!=NULL);
@@ -5372 +5372 @@
   if( rField_is_Extension(r) )
   {
-    const ring R = C->algring;
+    const ring R = C->extRing;
     assume( R != NULL );
     return idIs0(R->minideal);

libpolys/polys/monomials/ring.h

@@ -544 +544 @@
   if( rField_is_Extension(r) )
   {
-    const ring R = C->algring;
+    const ring R = C->extRing;
     assume( R != NULL );
     return rVar( R );
@@ -561 +561 @@
   if( rField_is_Extension(r) )
   {
-    const ring R = C->algring;
+    const ring R = C->extRing;
     assume( R != NULL );
     return R->names;

libpolys/tests/polys_test.h

@@ -563 +563 @@
     TS_ASSERT(type == n_algExt);
 
-    ExtInfo extParam;
+    AlgExtInfo extParam;
     extParam.r = r;
     extParam.i = minIdeal;
@@ -619 +619 @@
     
     poly u;
-    u = NULL; plusTerm(u, 1, 1, 1, cf->algring);
-    plusTerm(u, 1, 1, 0, cf->algring);  // a + 1
-    checkInverse((number)u, cf); p_Delete(&u, cf->algring);
-    u = NULL; plusTerm(u, 1, 1, 1, cf->algring);
-    plusTerm(u, -1, 1, 0, cf->algring); // a - 1
-    checkInverse((number)u, cf); p_Delete(&u, cf->algring);
-    u = NULL; plusTerm(u, 1, 1, 1, cf->algring);
-    plusTerm(u, 5, 1, 0, cf->algring);  // a + 5
-    checkInverse((number)u, cf); p_Delete(&u, cf->algring);
-    u = NULL; plusTerm(u, 1, 1, 1, cf->algring);
-    plusTerm(u, -5, 1, 0, cf->algring); // a - 5
-    checkInverse((number)u, cf); p_Delete(&u, cf->algring);
-    u = NULL; plusTerm(u, 17, 1, 1, cf->algring);
-    plusTerm(u, 5, 1, 0, cf->algring); // 17a + 5
-    checkInverse((number)u, cf); p_Delete(&u, cf->algring);
+    u = NULL; plusTerm(u, 1, 1, 1, cf->extRing);
+    plusTerm(u, 1, 1, 0, cf->extRing);  // a + 1
+    checkInverse((number)u, cf); p_Delete(&u, cf->extRing);
+    u = NULL; plusTerm(u, 1, 1, 1, cf->extRing);
+    plusTerm(u, -1, 1, 0, cf->extRing); // a - 1
+    checkInverse((number)u, cf); p_Delete(&u, cf->extRing);
+    u = NULL; plusTerm(u, 1, 1, 1, cf->extRing);
+    plusTerm(u, 5, 1, 0, cf->extRing);  // a + 5
+    checkInverse((number)u, cf); p_Delete(&u, cf->extRing);
+    u = NULL; plusTerm(u, 1, 1, 1, cf->extRing);
+    plusTerm(u, -5, 1, 0, cf->extRing); // a - 5
+    checkInverse((number)u, cf); p_Delete(&u, cf->extRing);
+    u = NULL; plusTerm(u, 17, 1, 1, cf->extRing);
+    plusTerm(u, 5, 1, 0, cf->extRing); // 17a + 5
+    checkInverse((number)u, cf); p_Delete(&u, cf->extRing);
 
     rDelete(s); // kills 'cf' and 'r' as well
@@ -664 +664 @@
     TS_ASSERT(type == n_algExt);
 
-    ExtInfo extParam;
+    AlgExtInfo extParam;
     extParam.r = r;
     extParam.i = minIdeal;
@@ -720 +720 @@
          
     poly u;
-    u = NULL; plusTerm(u, 1, 1, 2, cf->algring);
-    plusTerm(u, 33, 1, 0, cf->algring);     // b^2 + 33
-    checkInverse((number)u, cf); p_Delete(&u, cf->algring);
-    u = NULL; plusTerm(u, 1, 1, 5, cf->algring);
-    plusTerm(u, -137, 1, 0, cf->algring);   // b^5 - 137
-    checkInverse((number)u, cf); p_Delete(&u, cf->algring);
+    u = NULL; plusTerm(u, 1, 1, 2, cf->extRing);
+    plusTerm(u, 33, 1, 0, cf->extRing);     // b^2 + 33
+    checkInverse((number)u, cf); p_Delete(&u, cf->extRing);
+    u = NULL; plusTerm(u, 1, 1, 5, cf->extRing);
+    plusTerm(u, -137, 1, 0, cf->extRing);   // b^5 - 137
+    checkInverse((number)u, cf); p_Delete(&u, cf->extRing);
 
     clog << endl
@@ -732 +732 @@
     
     poly v;
-    v = NULL; plusTerm(v, 1, 1, 2, cf->algring);
-    plusTerm(v, 7, 1, 1, cf->algring);
-    plusTerm(v, 1, 1, 0, cf->algring);            // b^2 + 7b + 1
+    v = NULL; plusTerm(v, 1, 1, 2, cf->extRing);
+    plusTerm(v, 7, 1, 1, cf->extRing);
+    plusTerm(v, 1, 1, 0, cf->extRing);            // b^2 + 7b + 1
     number w = n_Mult((number)v, (number)v, cf);  // (b^2 + 7b + 1)^2
     number y = n_Mult((number)v, (number)w, cf);  // (b^2 + 7b + 1)^3
-    p_Delete(&v, cf->algring);
-    v = NULL; plusTerm(v, 2, 1, 2, cf->algring);
-    plusTerm(v, -61, 1, 1, cf->algring);          // 2b^2 - 61b
+    p_Delete(&v, cf->extRing);
+    v = NULL; plusTerm(v, 2, 1, 2, cf->extRing);
+    plusTerm(v, -61, 1, 1, cf->extRing);          // 2b^2 - 61b
     number z = n_Mult((number)w,
                       (number)v, cf);   // (b^2 + 7b + 1)^2 * (2b^2 - 61b)
-    p_Delete(&v, cf->algring);
-    
-    clog << "z = "; p_Write((poly)z, cf->algring);
-    clog << "y = "; p_Write((poly)y, cf->algring);
+    p_Delete(&v, cf->extRing);
+    
+    clog << "z = "; p_Write((poly)z, cf->extRing);
+    clog << "y = "; p_Write((poly)y, cf->extRing);
     number theGcd = n_Gcd(z, y, cf);   // should yield w = (b^2 + 7b + 1)^2
-    clog << "gcd(z, y) = "; p_Write((poly)theGcd, cf->algring);
+    clog << "gcd(z, y) = "; p_Write((poly)theGcd, cf->extRing);
     
     v = (poly)n_Sub(theGcd, w, cf);
     TS_ASSERT( v == NULL );
-    p_Delete(&v, cf->algring);
+    p_Delete(&v, cf->extRing);
     
     clog << endl
@@ -758 +758 @@
          
     poly zFactor; poly yFactor;
-    poly ppp = p_ExtGcd((poly)z, zFactor, (poly)y, yFactor, cf->algring);
+    poly ppp = p_ExtGcd((poly)z, zFactor, (poly)y, yFactor, cf->extRing);
     v = (poly)n_Sub(theGcd, (number)ppp, cf);
     TS_ASSERT( v == NULL );
-    clog << "z = "; p_Write((poly)z, cf->algring);
-    clog << "zFactor = "; p_Write(zFactor, cf->algring);
-    clog << "y = "; p_Write((poly)y, cf->algring);
-    clog << "yFactor = "; p_Write((poly)yFactor, cf->algring);
+    clog << "z = "; p_Write((poly)z, cf->extRing);
+    clog << "zFactor = "; p_Write(zFactor, cf->extRing);
+    clog << "y = "; p_Write((poly)y, cf->extRing);
+    clog << "yFactor = "; p_Write((poly)yFactor, cf->extRing);
     number v1 = n_Mult(z, (number)zFactor, cf);
     number v2 = n_Mult(y, (number)yFactor, cf);
     number v3 = n_Add(v1, v2, cf);
-    clog << "z * zFactor + y * yFactor = "; p_Write((poly)v3, cf->algring);
-    clog << "gcd(z, y) = "; p_Write(ppp, cf->algring);
+    clog << "z * zFactor + y * yFactor = "; p_Write((poly)v3, cf->extRing);
+    clog << "gcd(z, y) = "; p_Write(ppp, cf->extRing);
     number v4 = n_Sub(v3, w, cf);
     TS_ASSERT( v4 == NULL );
     
-    p_Delete(&ppp, cf->algring); p_Delete(&zFactor, cf->algring);
-    p_Delete(&yFactor, cf->algring);
+    p_Delete(&ppp, cf->extRing); p_Delete(&zFactor, cf->extRing);
+    p_Delete(&yFactor, cf->extRing);
     n_Delete(&z, cf); n_Delete(&y, cf); n_Delete(&w, cf);
-    n_Delete(&theGcd, cf); p_Delete(&v, cf->algring); n_Delete(&v1, cf);
+    n_Delete(&theGcd, cf); p_Delete(&v, cf->extRing); n_Delete(&v1, cf);
     n_Delete(&v2, cf); n_Delete(&v3, cf); n_Delete(&v4, cf);
 
@@ -808 +808 @@
     TS_ASSERT(type == n_algExt);
 
-    ExtInfo extParam;
+    AlgExtInfo extParam;
     extParam.r = r;
     extParam.i = minIdeal;